DPF data processing framework

Overview Main Data Types APIs

Available Operators

Overview of Data Processing Framework

The Data Processing Framework (DPF) is designed to provide numerical simulation users/engineers with a toolbox for accessing and transforming simulation data. DPF can access data from solver result files as well as several neutral formats (csv, hdf5, vtk, etc.). Various operators are available allowing the manipulation and the transformation of this data. DPF is a workflow-based framework which allows simple and/or complex evaluations by chaining operators. The data in DPF is defined based on physics agnostic mathematical quantities described in a self-sufficient entity called field. This allows DPF to be a modular and easy to use tool with a large range of capabilities. It's a product designed to handle large amount of data.

Advantages

Computation efficiency
DPF is a modern framework and it has been developed by taking advantages of new hardware architectures. Due to continued development, new capabilities are frequently added.
Genericity
DPF is physic agnostic. Therefore, its use is not limited to a particular field.
Extensibility and Customization
DPF is developed around two entities, one for the data (field) and one for the operation (operator). Each DPF capability is developed through operators, allowing componentization of the framework. DPF is also plugin based so adding new features or handling new formats is fast and easy. With componentization, plugins, and DPF scripting, you can add your own capabilities and link your existing work with DPF.

Overview of Data Processing Framework

The Data Processing Framework (DPF) is designed to provide numerical simulation users/engineers with a toolbox for accessing and transforming simulation data. DPF can access data from solver result files as well as several neutral formats (csv, hdf5, vtk, etc.). Various operators are available allowing the manipulation and the transformation of this data. DPF is a workflow-based framework which allows simple and/or complex evaluations by chaining operators. The data in DPF is defined based on physics agnostic mathematical quantities described in a self-sufficient entity called field. This allows DPF to be a modular and easy to use tool with a large range of capabilities. It's a product designed to handle large amount of data.

Advantages

Computation efficiency
DPF is a modern framework and it has been developed by taking advantages of new hardware architectures. Due to continued development, new capabilities are frequently added.
Genericity
DPF is physic agnostic. Therefore, its use is not limited to a particular field.
Extensibility and Customization
DPF is developed around two entities, one for the data (field) and one for the operation (operator). Each DPF capability is developed through operators, allowing componentization of the framework. DPF is also plugin based so adding new features or handling new formats is fast and easy. With componentization, plugins, and DPF scripting, you can add your own capabilities and link your existing work with DPF.

How to transform the data

Operator

The Operator is the main object used to create, transform and stream the data. It can be seen as an integrated circuit in electronics with a range of pins in input and in output. When the operator is evaluated, it will process the input information to compute its output with respect to its description. The operator is made of:

image/svg+xml operator pin 0 pin 0 fieldA pin 1 fieldB fieldOut inputs outputs

  • Inputs: the input pins allow the user to pass on his data to the operator. Dpf data container types, standard types or operators' outputs can be connected on the input pins (connecting an operator output to another operator input doesn't evaluate this input operator). The inputs allow the user to choose the time/frequencies on which to evaluate a result, to specify the files where to find a result, to provide a field on which he wants an operation to be computed... Optional input pins allow to customize even more the operator outputs. Here is some of the most common pins:

    pin 0requested
    fieldsname
    (field | fields_container)expected type(s)
    field(s) containing the data to transform
    pin 0optional
    time_scopingname
    (scoping | vector | int | double | field)expected type(s)
    time freq set or time/frequencies needed in output. The sets are ids from 1 to the number of time/freq
    pin 1optional
    mesh_scopingname
    (scoping | scopings_container)expected type(s)
    mesh node or elements needed in output
    pin 4requested
    data_sourcesname
    (data_sources)expected type(s)
    list of file path indicating where is the data
    pin 3requested
    streams_containername
    (streams_container)expected type(s)
    list of files allowed to stay open to cache some data, a result provider needs either a streams_container or a data_sources
    pin 7optional
    meshname
    (meshed_region | meshes_container)expected type(s)
    mesh(es) supporting the results or mesh(es) to transform

  • Configurations: with configurations the user can optionally choose how the operator will run. This is an advanced feature used for deep customization. The different options can change the way loops are done, it can change whether the operator needs to make check on the input or not... Here is some of the most common configuration options:

        binary_operationname
    (int32)expected type(s)
    This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
        incrementalname
    (bool)expected type(s)
    This operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
        inplacename
    (bool)expected type(s)
    The output is written over the input to save memory if this config is set to true.
        mutexname
    (bool)expected type(s)
    If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
        num_threadsname
    (int32)expected type(s)
    Number of threads to use to run in parallel
        permissivename
    (bool)expected type(s)
    If this option is set to true, warning checks (like unit or data sizes) won't be done.
        read_inputs_in_parallelname
    (bool)expected type(s)
    If this option is set to true, the operator's inputs will be evaluated in parallel.
        run_in_parallelname
    (bool)expected type(s)
    Loops are allowed to run in parallel if the value of this config is set to true.
        use_cachename
    (bool)expected type(s)
    Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
        work_by_indexname
    (bool)expected type(s)
    If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

  • Data transformation: this is the internal operation that will occur when an operator is evaluated. The operation will return outputs depending on the inputs and configurations given by the user. The operation applied by each operator is described in its description.


  • Outputs: this is the results of the operation. An Operator can have one or several outputs which are usually DPF data containers.

Operators can be chained together to create workflows. To do so, the user only needs to connect some operator's outputs to an other operator's inputs. With workflows, lazy evaluation is performed, which means that when the last operator's outputs are asked by the user, all the connected operators will also be evaluated (and not before) to compute a given result. All the inputs, outputs and description information can be found by clicking on operators on the left pannel of this documentation.

Workflow

The workflow is built by chaining operators. It will evaluate the data processing defined by the used operators. It needs input information, and it will compute the requested output information. The workflow is used to create a black box computing more or less basic transformation of the data. The different operators contained by a workflow can be internally connected together so that the end user doesn't need to be aware of its complexity. The workflow only needs to expose the necessary inputs pin and output pins. For example, a workflow could expose a "time scoping" input pin and a "data sources" input pin and expose a "result" output pin and have very complex routines inside it. See workflows' examples in the APIs tab.

image/svg+xml field out data sources Displacement pin 0 pin 0 inputs outputs Norm pin 0 pin 0 inputs outputs Total deformation workflow

Overview of the main data containers types

Field

The field is the main simulation data container. In numerical simulations, results data are defined by values associated to entities (scoping), and these entities are a subset of a model (support). In DPF, field data is always associated to its scoping and support, making the field a self-describing piece of data. A field is also defined by its dimensionnality, unit, location... A field can for example, describe a displacement vector or norm, stresses and strains tensors, stresses and strains equivalent, min max over time of any result... It can be defined on a complete model or just on certain entities of the model thanks to its scoping. The data is stored as a vector of double values and each elementary entity has a number of components (thanks to the dimensionality, a displacement will have 3 components, a symmetrical stress matrix 6...)

Scoping

The scoping is entities ids representing a subset of the model's support. Typically, scoping can represent node ids, element ids, time steps, frequencies, joints... Its location indicates what kind of entity the scoping is referring to. Scopings are used to identify the entities where a field is scoped or to choose (through an input pin) a subset on which an operator should compute its result.

Data Sources

The data sources is a container of files on which the analysis results can be found.

Streams

Streams is an entity containing the data sources. Once the files in the streams are opened, they stay opened and they keep some data in cache to make the next evaluations faster. To close the files, release the streams.

Support

The support describes the model. It can be the mesh, geometric entities, time or frequency domain...

Fields Container

The fields container is a container of fields, used mainly in transient, harmonic, modal or multi-steps static analysis, where we can have a field for each time step or for each frequency. Consequently the fields container can describle a complete analysis with all its details. The fields container is designed as a set of fields ordered through labels and ids. Labels identify how the fields are filtered. The most common fields container have the label "time" with ids corresponding to each time sets, the label "complex" will allow to separate real parts (id=0) from imaginary parts (id=1) in a harmonic analysis.

Meshed Region

The meshed region is dpf's entity describing a mesh. Node and element scopings, element types, connectivity (list of node indices composing each element) and node coordinates are the fundamental entities composing the meshed region. It can also have materials, named selections...

Time Freq Support

The time freq support describes an analysis' temporal or frequential space. For a transient analysis all the time sets cumulatives indices with their times are described. For a harmonic analysis, the real and imaginary frequencies, the RPMs, the load steps are described.

Model

The model is a helper designed to give shortcuts to the user to access a model's metadata and to instanciate results provider for this model. A Model is able to open a DataSources or a Streams to read the metadata and expose it to the user. The metadata is made of all the entities describing a model: its MeshedRegion, its TimeFreqSupport and its ResultInfo. With the model, the user can easily access information about the mesh, about the time/freq steps and substeps used in the analysis and the list of available results.

Using DPF's entities in scripting

Scoping

Create a Scoping

The Scoping is a set of entity ids defined on a location (the location is optional).

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

# 1. create a generic scoping from scratch
my_scoping = dpf.Scoping()
my_scoping.Location = "Nodal" #optional
my_scoping.Ids = range(1,11)


# 2. create a mesh scoping using the MeshScopingFactory
# a. scoping with elemental location that targets the elements with id 2, 7 and 11
my_elemental_scoping = dpf.MeshScopingFactory.ElementalScoping([2, 7, 11])
# b. scoping with nodal location that targets the elements with id 4 and 6
my_nodal_scoping = dpf.MeshScopingFactory.NodalScoping([4, 6])

# 3. create a time_freq_support Scoping using the TimeFreqScopingFactory
my_load_step_scoping = dpf.TimeFreqScopingFactory.ScopingByLoadStep(2)
# creates a TimeFreqSupport Scoping that targets the second load step
from ansys.dpf import core as dpf

# 1. create a generic scoping from scratch
my_scoping = dpf.Scoping()
my_scoping.location = dpf.locations.nodal #optional
my_scoping.ids = list(range(1,11))

# 2. create a mesh scoping using the mesh_scoping_factory
from ansys.dpf.core import mesh_scoping_factory
# a. scoping with elemental location that targets the elements with id 2, 7 and 11
my_elemental_scoping = mesh_scoping_factory.elemental_scoping([2, 7, 11])
# b. scoping with nodal location that targets the elements with id 4 and 6
my_nodal_scoping = mesh_scoping_factory.nodal_scoping([4, 6])

# 3. create a time_freq_support Scoping using the time_freq_support_scoping_factory
from ansys.dpf.core import time_freq_scoping_factory
my_load_step_scoping = time_freq_scoping_factory.scoping_by_load_step(2)
# creates a TimeFreqSupport Scoping that targets the second load step
#include "dpf_api.h"
#include "dpf_api_i.cpp"

ansys::dpf::Scoping my_scoping;
my_scoping.setLocation(ansys::dpf::locations::nodal);

// 1/ entity by entity
my_scoping.emplace(0, 1);
my_scoping.emplace(1, 2);
my_scoping.emplace(2, 3);
// 2/ or the entire vector of ids
std::vector<int> my_ids = { 1,2,3 };
my_scoping.setIds(my_ids);
// or
my_scoping.setIds(my_ids.data(), (int)my_ids.size());

Get Scoping's data

The Scoping's location and ids can be accessed with:

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

my_scoping.Location
my_scoping.Ids
from ansys.dpf import core as dpf

my_scoping.location
my_scoping.ids
#include "dpf_api.h"
#include "dpf_api_i.cpp"

ansys::dpf::Location my_loc = my_scoping.location();
std::vector<int> my_ids_out;
my_scoping.getIds(my_ids_out);

int size = 0;
const int* ids = my_scoping.ids(size);

// or entity by entity
int id = my_scoping.idByIndex(0);
int index = my_scoping.indexById(1);

Field

Create a Field

The minimum requirement for a well defined Field is for it to have a dimensionality (scalar, 3 components vector, 6 components symmetrical matrix...), a location ("Nodal", "Elemental", "ElementalNodal", "Timefrq"...), a data vector and a scoping with ids. The user can also set the number of shell layers. If the field has one elementary data by entity (elementary data size = number of components for "Nodal" or "Elemental" field for example), then the data vector can be set directly. If a more complex field is required ("ElementalNodal" Field for example), the data can be set entity by entity.

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

num_entities = 2

#create a field by RESERVING a size of num_entities
# for the most common dimensionalities
my_field = dpf.FieldsFactory.CreateScalarField(num_entities, "Nodal")
my_field = dpf.FieldsFactory.CreateVectorField(num_entities, "Nodal")
my_field = dpf.FieldsFactory.CreateTensorField(num_entities, "Elemental")


my_scoping = dpf.Scoping()
my_scoping.Location = "Elemental"
my_scoping.Ids = range(1,3)

my_field.Scoping = my_scoping

#sym matrix are defined by 6 components in the order XX,YY,ZZ,XY,YZ,XZ
#all the data at once
my_data = [1.0,1.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0] #2 sym identity tensors
my_field.Data = my_data

#or entity by entity once the scoping is already set
my_elem_data = [1.0,1.0,1.0,0.0,0.0,0.0]
my_field.UpdateEntityDataByEntityIndex(0,my_elem_data) #index, data
my_field.UpdateEntityDataByEntityIndex(1,my_elem_data) #index, data

#or entity by entity by pushing back the scoping ids and the data
my_field = dpf.FieldsFactory.CreateTensorField(num_entities, "Elemental")
my_field.Add(1,my_elem_data) #id, data
my_field.Add(2,my_elem_data) #id, data

#optional, set the field's unit
my_field.Unit = "m" #"Pa", "Hz"...
from ansys.dpf import core as dpf

# 1. Create a field from scratch
num_entities = 2

# for the most common dimensionalities
my_field = dpf.Field(num_entities, dpf.natures.scalar, "Nodal")
my_field = dpf.Field(num_entities, dpf.natures.vector, "ElementalNodal")
my_field = dpf.Field(num_entities, dpf.natures.symmatrix, "Elemental")


my_scoping = dpf.Scoping()
my_scoping.location = "Elemental"
my_scoping.ids = list(range(1,3))

my_field.scoping = my_scoping

#sym matrix are defined by 6 components in the order XX,YY,ZZ,XY,YZ,XZ
#all the data at once
my_data = [1.0,1.0,1.0,0.0,0.0,0.0,1.0,1.0,1.0,0.0,0.0,0.0] #2 sym identity tensors
my_field.data = my_data

#or entity by entity
my_elem_data = [1.0,1.0,1.0,0.0,0.0,0.0]
my_field.append(my_elem_data, scopingid=1)
my_field.append(my_elem_data, scopingid=2)

#optional, set the field's unit
my_field.unit = "m" #"Pa", "Hz"...


# 2. Create a field using the fields_factory
from ansys.dpf.core import fields_factory

# create a scalar field with 2 entities
my_scalar_field = fields_factory.create_scalar_field(2)
my_scalar_field.data = [1.0, 3.0]

# create a 3d vector field 
my_vector_field = fields_factory.create_3d_vector_field(2)
my_vector_field.append([0.1, 0.3, 1.0], 1)
my_vector_field.append([0.4, 1.0, 1.0], 2)

#include "dpf_api.h"
#include "dpf_api_i.cpp"

int num_entities = 2;

// for the most common dimensionalities
ansys::dpf::Field my_field(num_entities, { 1 }, ansys::dpf::locations::nodal); //nodal scalar
my_field = ansys::dpf::Field(num_entities, { 3 }, ansys::dpf::locations::elemental_nodal); //elemental nodal vector
my_field = ansys::dpf::Field(num_entities, { 3,3 }, ansys::dpf::locations::elemental); //elemental sym matrix

// 1/ fill the entire Scoping and data
std::vector<double> my_data = { 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 2.3, 1.0, 1.0, 0.0, 0.0, 1.0 };
my_field.scoping().setIds({ 5,22 });
my_field.setData(my_data);

// 2/ or fill entity by entity
my_field = ansys::dpf::Field(num_entities, { 3,3 }, ansys::dpf::locations::elemental); //elemental sym matrix
// sym matrix are defined by 6 components in the order XX, YY, ZZ, XY, YZ, XZ
std::vector<double> my_elem_data = { 1.0, 1.0, 1.0, 0.0, 0.0, 0.0 };
my_field.push_back(5, my_elem_data);

std::vector<double> my_elem_data2 = { 2.3, 1.0, 1.0, 0.0, 0.0, 1.0 };
my_field.push_back(22, my_elem_data2);

//optional, set the field's unit
ansys::dpf::FieldDefinition field_def = my_field.fieldDefinition();
field_def.setUnit(ansys::dpf::Unit("m"));
my_field.setFieldDefinition(field_def);

Get Field's data

The Field's side information as well as the data in itself can be accessed with:

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

my_field.ComponentCount #returns the number of component of the elementary data
my_field.Location
my_field.Scoping
my_field.Unit

my_field.Data #returns the full list of data
my_field.GetEntityDataByIndex(0) #returns the data list for the first entity
my_field.GetEntityDataById(1) #returns the data list for the entity of scoping's id 1
from ansys.dpf import core as dpf

my_field.component_count #returns the number of component of the elementary data
my_field.location
my_field.scoping
my_field.unit
my_field.shape #returns a tuple of data format

my_field.data #returns a numpy array of the data
my_field.get_entity_data(0) #returns the data numpy array for the first entity
my_field.get_entity_data_by_id(1) #returns the data numpy array for the entity of scoping's id 1
#include "dpf_api.h"
#include "dpf_api_i.cpp"

int ncomp = my_field.numberOfComponents(); //returns the nuber of component of the elementary data
ansys::dpf::Location loc = my_field.fieldDefinition().location();
ansys::dpf::Unit unit = my_field.fieldDefinition().unit();
ansys::dpf::Scoping scoping = my_field.scoping();

int size = 0;
double* data = my_field.data(size); //returns the ptr to the full list of data
int entity_size = 0;
int index = 1;
double* data_by_index = my_field.entityData(index, entity_size);//returns the ptr to the list of data of the second entity
int id = 22;
double* data_by_id = my_field.entityDataById(id, entity_size);//returns the ptr to the list of data of the second entity

//the cursor represents a complete entity data (id, size, num elementary data)
ansys::dpf::FieldCursor cursor;
my_field.fillCursor(1, cursor);//fills the cursor on the second entity
id = cursor.id();
entity_size = cursor.size();
int num_elem_data = cursor.n_elementary_data();
data_by_index = cursor.data();

Fields Container

Create a Fields Container

The Fields Container is a vector of Fields and all the Fields are ordered with labels and ids. Most commonly, the Fields Container is scoped on "time" label and the ids are the time or frequency sets. More generically, the Fields Container allows to split results on different criterions.

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

#1. create over time freq fields container with helpers:

time1_disp = dpf.FieldsFactory.Create3DVectorField(numEntities=100)
time2_disp = dpf.FieldsFactory.Create3DVectorField(numEntities=100)
#to fill those fields, see create field menu

#create a fields container with a list of fields
my_displacements = dpf.FieldsContainerFactory.OverTimeFreqFieldsContainer([time1_disp, time2_disp])
#create a fields container with a dictionnary time/freq->field to specify the time freq support of each field
#specifying the unit of the time/freq
my_displacements = dpf.FieldsContainerFactory.OverTimeFreqFieldsContainer({0.1:time1_disp, 0.2:time2_disp}, "s")

#create a complex fields container
#each complex array needs to be specified with one real field and one imaginary field
time1_real_disp = dpf.FieldsFactory.Create3DVectorField(numEntities=100)
time2_real_disp = dpf.FieldsFactory.Create3DVectorField(numEntities=100)
time1_im_disp = dpf.FieldsFactory.Create3DVectorField(numEntities=100)
time2_im_disp = dpf.FieldsFactory.Create3DVectorField(numEntities=100)
#create a fields container with a list of fields
my_complex_displacements = dpf.FieldsContainerFactory.OverTimeFreqComplexFieldsContainer([time1_real_disp, time2_real_disp],[time1_im_disp, time2_im_disp])
#create a fields container with a dictionnary freq->field to specify the freq support of each field
my_complex_displacements = dpf.FieldsContainerFactory.OverTimeFreqComplexFieldsContainer({100.0:time1_real_disp, 200.0:time2_real_disp},{100.0:time1_im_disp, 200.0:time2_im_disp},"Hz")


#2. Create a generic fields container from scratch.
#Using a generic fields container allows you to define your own space, splitting the fields.
#Labels define this space. For example, the labels can be "time", "eltype" to define fields over time with one field by element type.
#Each field added must be defined on that space:
#field1: "time":1, "eltype":8
#field2: "time":1, "eltype":10
#field3: "time":2, "eltype":8
#field4: "time":2, "eltype":10
my_fc = dpf.FieldsContainer()
my_fc.Labels = ["time","eltype"]
my_fc.Add(time1_real_disp, {"time":1, "eltype":8})
my_fc.Add(time1_disp, {"time":1, "eltype":10})
my_fc.Add(time2_real_disp, {"time":2, "eltype":8})
my_fc.Add(time2_disp, {"time":2, "eltype":10})




from ansys.dpf.core import fields_factory, fields_container_factory

#1. create over time freq fields container with helpers:
time1_disp = fields_factory.create_scalar_field(num_entities = 100)
time2_disp = fields_factory.create_scalar_field(num_entities = 100)
#to fill those fields, see create field menu

#create a fields container with a list of fields
my_displacements = fields_container_factory.over_time_freq_fields_container([time1_disp, time2_disp])
#create a fields container with a dictionnary time/freq->field to specify the time freq support of each field
#specifying the unit of the time/freq
my_displacements = fields_container_factory.over_time_freq_fields_container({0.1 : time1_disp, 0.2 : time2_disp}, 's')

#create a complex fields container
#each complex array needs to be specified with one real field and one imaginary field
time1_real_disp = fields_factory.create_3d_vector_field(num_entities = 100)
time2_real_disp = fields_factory.create_3d_vector_field(num_entities = 100)
time1_im_disp = fields_factory.create_3d_vector_field(num_entities = 100)
time2_im_disp = fields_factory.create_3d_vector_field(num_entities = 100)
#create a fields container with a list of fields
my_complex_displacements = fields_container_factory.over_time_freq_complex_fields_container([time1_real_disp, time2_real_disp],[time1_im_disp, time2_im_disp])
#create a fields container with a dictionnary freq->field to specify the freq support of each field
my_complex_displacements = fields_container_factory.over_time_freq_complex_fields_container({100.0 : time1_real_disp, 200.0 : time2_real_disp},{100.0 : time1_im_disp, 200.0 : time2_im_disp}, 'Hz')


#2. create a generic fields container from scratch
#using generic fields container allows to define you own space splitting the fields
#labels define this space
#for example, the labels can be 'time', 'eltype' to define fields over time with one field by element type
#each field added need to be defined on that space:
#field1: 'time':1, 'eltype':8
#field2: 'time':1, 'eltype':10
#field3: 'time':2, 'eltype':8
#field4: 'time':2, 'eltype':10
my_fc = dpf.FieldsContainer()
my_fc.labels = ['time', 'eltype']
my_fc.add_field({'time' : 1, 'eltype' : 8}, time1_real_disp)
my_fc.add_field({'time' : 1, 'eltype' : 10}, time1_disp)
my_fc.add_field({'time' : 2, 'eltype' : 8}, time2_real_disp)
my_fc.add_field({'time' : 2, 'eltype' : 10}, time2_disp)
#include "dpf_api.h"
#include "dpf_api_i.cpp"

//Create a generic fields container from scratch.
//Using a generic fields container allows you to define your own space, splitting the fields.
//Labels define this space. For example, the labels can be "time", "eltype" to define fields over time with one field by element type.
//Each field added must be defined on that space:
//field1 : "time" : 1, "eltype" : 8
//field2 : "time" : 1, "eltype" : 10
//field3 : "time" : 2, "eltype" : 8
//field4 : "time" : 2, "eltype" : 10

ansys::dpf::Field field_1;
ansys::dpf::Field field_2;
ansys::dpf::Field field_3;
ansys::dpf::Field field_4;

ansys::dpf::FieldsContainer my_fc;
my_fc.addLabels({ ansys::dpf::labels::time, ansys::dpf::Label("eltype") });
ansys::dpf::LabelSpace label_space = { { ansys::dpf::labels::time,1 },{ ansys::dpf::Label("eltype"),8 } };
my_fc.add(label_space, field_1);
my_fc.add({ { ansys::dpf::labels::time,1 },{ ansys::dpf::Label("eltype"),10 } }, field_2);
my_fc.add({ { ansys::dpf::labels::time,2 },{ ansys::dpf::Label("eltype"),8 } }, field_3);
my_fc.add({ { ansys::dpf::labels::time,2 },{ ansys::dpf::Label("eltype"),10 } }, field_4);

//to create a fields container for complex results, use the ansys::dpf::labels::complex label
//with value 1 for imaginary fields and 0 for real fields:
ansys::dpf::FieldsContainer my_complex_fc;
my_complex_fc.addLabels({ ansys::dpf::labels::time, ansys::dpf::labels::complex });

//real part for time set 1
my_complex_fc.add({ { ansys::dpf::labels::time,1 },{ ansys::dpf::labels::complex, 0 } }, field_1);
//imaginary part for time set 1
my_complex_fc.add({ { ansys::dpf::labels::time,1 },{ ansys::dpf::labels::complex, 1 } }, field_2);


Get Fields Container's data

The Fields Container is the main output of results providers:

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

u_op = ops.result.displacement() 
u_op.inputs.data_sources.Connect(my_data_sources) 
my_fields_container = u_op.outputs.fields_container.GetData()

my_fields_container.FieldCount

index=0
#returns the labels and ids corresponding to the first field
my_fields_container.GetLabelSpace(index) #ie. {'time',1} for the first time set
#return the real Fields on {'time',1}
my_field = my_fields_container.GetFieldByTimeId(1)
my_field = my_fields_container.Get({'time':1}) #same

my_field = my_fields_container[0] #returns the first Field
from ansys.dpf import core as dpf

model = dpf.Model(my_data_sources)
u_op = model.results.displacement()
my_fields_container = u_op.outputs.fields_container()

len(my_fields_container)

index=0
#returns the labels and ids corresponding to the first field
my_fields_container.get_label_space(index) #ie. {'time',1} for the first time set
#return the real Fields on {'time',1}
my_field = my_fields_container.get_fields_by_time_complex_ids(1,0) 	
my_field = my_fields_container.get_fields({'time':1},{'complex':0}) #same

my_field = my_fields_container[0] #returns the first Field
#include "dpf_api.h"
#include "dpf_api_i.cpp"

ansys::dpf::Operator u_op("U");
u_op.connect(ansys::dpf::eDataSourcesPin, my_data_sources);
auto my_fields_container = u_op.getOutputFieldsContainer(0);

int num_fields = my_fields_container.size();

int index = 0;
//returns the labels and ids corresponding to the first Field
ansys::dpf::LabelSpace label_space = my_fields_container.getLabelSpace(index); //ie. {'time',1} for the first time set

                                                                               //return the real Fields on{ 'time',1 }
ansys::dpf::Field my_field = my_fields_container.getFields({ { ansys::dpf::labels::time,1 } })[0];
my_field = my_fields_container.getFieldsForTimeId(1)[0];

my_field = my_fields_container[0]; //returns the first field

Data Sources

Create Data Sources

Data Sources is the entity containing the different path to the result files of an analysis. An extension key ('rst' for example) is used to choose which files represent results files, the other one being accessory files. See more information for using Data Sources in mechanical in "How to use DPF's package / IPython" menu.

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

my_data_sources = dpf.DataSources()
my_data_sources.SetResultFilePath(r'c:/temp/file.rst','rst')
my_data_sources.AddFilePath(r'c:/temp/ds.dat')
from ansys.dpf import core as dpf

my_data_sources = dpf.DataSources()
my_data_sources.set_result_file_path(r'c:/temp/file.rst')
my_data_sources.add_file_path(r'c:/temp/ds.dat')
#include "dpf_api.h"
#include "dpf_api_i.cpp"

ansys::dpf::DataSources my_data_sources;
my_data_sources.addResultFile("c:/temp/file.rst");
my_data_sources.addFile("c:/temp/ds.dat");

Meshed Region

Create a Meshed Region

The user can create his own data to manipulate it with dpf. The Meshed Region can be created simply with:

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

#create a new mesh with 1 quad, 1 beam, 1 point element and 1 tetra
mesh = dpf.MeshedRegion(numNodes = 11, numElements = 4) #reserve the size of the mesh
mesh.NodeCount
#return:
#0
mesh.ElementCount
#return:
#0

#quad element with 4 nodes
mesh.AddNode(1, [ 0.0, 0.0, 0.0 ])
mesh.AddNode(2, [ 1.0, 0.0, 0.0 ])
mesh.AddNode(3, [ 1.0, 1.0, 0.0 ])
mesh.AddNode(4, [ 0.0, 1.0, 0.0 ])
mesh.AddShellElement(1, [ 0, 1, 2, 3 ]) #connectivity is by node indexes

#point element
mesh.AddNode(5, [0.0, 0.0, 0.0 ])
mesh.AddPointElement(2, [ 4 ])

#beam element
mesh.AddNode(6, [0.0, 0.0, 0.0])
mesh.AddNode(7, [1.0, 0.0, 0.0])
mesh.AddBeamElement(3, [ 5, 6 ])

#tetra element with 4 nodes
mesh.AddNode(8, [0.0, 0.0, 0.0])
mesh.AddNode(9, [1.0, 0.0, 0.0])
mesh.AddNode(10, [1.0, 1.0, 0.0])
mesh.AddNode(11, [0.0, 1.0, 1.0])
mesh.AddSolidElement(4, [ 7, 8, 9, 10])

mesh.NodeCount
#return:
#11
mesh.ElementCount
#return:
#4

mesh.ElementById(1).NodeIds
#return:
#[ 1, 2, 3, 4 ]
from ansys.dpf import core as dpf

#create a new mesh with 1 quad, 1 beam, 1 point element and 1 tetra
mesh = dpf.MeshedRegion(num_nodes=11, num_elements=4) #reserve the size of the mesh
mesh.nodes.n_nodes
#return:
#0
mesh.elements.n_elements
#return:
#0

#quad element with 4 nodes
mesh.nodes.add_node(1, [0.0,0.0,0.0])
mesh.nodes.add_node(2, [1.0,0.0,0.0])
mesh.nodes.add_node(3, [1.0,1.0,0.0])
mesh.nodes.add_node(4,[0.0,1.0,0.0])
mesh.elements.add_shell_element(1, [0,1,2,3])    

#point element
mesh.nodes.add_node(5, [0.0,0.0,0.0])
mesh.elements.add_point_element(2, [4])

#beam element
mesh.nodes.add_node(6, [0.0,0.0,0.0])
mesh.nodes.add_node(7, [1.0,0.0,0.0])
mesh.elements.add_beam_element(3, [5,6])

#tetra element with 4 nodes
mesh.nodes.add_node(8, [0.0,0.0,0.0])
mesh.nodes.add_node(9, [1.0,0.0,0.0])
mesh.nodes.add_node(10, [1.0,1.0,0.0])
mesh.nodes.add_node(11, [0.0,1.0,1.0])
mesh.elements.add_solid_element(4, [7,8,9,10])
    
mesh.nodes.n_nodes 
#return:
#11
mesh.elements.n_elements
#return:
#4

el = mesh.elements.element_by_id(1)
el.shape
#return:
#"shell
#include "dpf_api.h"
#include "dpf_api_i.cpp"

//create a new mesh with 1 quad, 1 beam, 1 point element and 1 tetra
ansys::dpf::MeshedRegion mesh;
mesh.prepareConstruction(11, 4); //reserve the size of the mesh
mesh.nodeScoping().size();
//return:
//0

mesh.elementScoping().size();
//return:
//0

//quad element with 4 nodes
mesh.addNode(1, { 0.0, 0.0, 0.0 });
mesh.addNode(2, { 1.0, 0.0, 0.0 });
mesh.addNode(3, { 1.0, 1.0, 0.0 });
mesh.addNode(4, { 0.0, 1.0, 0.0 });
mesh.addElement(ansys::dpf::elements::quad4, 1, { 0, 1, 2, 3 }); // connectivity is by node indexes

//point element
mesh.addNode(5, { 0.0, 0.0, 0.0 });
mesh.addElement(ansys::dpf::elements::point1, 2, { 4 });

//beam element
mesh.addNode(6, { 0.0, 0.0, 0.0 });
mesh.addNode(7, { 1.0, 0.0, 0.0 });
mesh.addElement(ansys::dpf::elements::line2, 3, { 5, 6 });

//tetra element with 4 nodes
mesh.addNode(8, { 0.0, 0.0, 0.0 });
mesh.addNode(9, { 1.0, 0.0, 0.0 });
mesh.addNode(10, { 1.0, 1.0, 0.0 });
mesh.addNode(11, { 0.0, 1.0, 1.0 });
mesh.addElement(ansys::dpf::elements::tet4, 4, { 7, 8, 9, 10 });

mesh.nodeScoping().size();
//return:
//11

mesh.elementScoping().size();
//return:
//4

ansys::dpf::ElementCursor el;
mesh.fillCursor(0, el);
el.numberOfNodes();
//return:
//4

Get Meshed Region's data from DataSources

A model is usually represented by a Meshed Region in DPF. The mesh provider operator allows to access an analysis' mesh. The user can then get different information in the mesh like the coordinates of all the nodes and the connectivity between elements and nodes.

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

mesh_prov = ops.mesh.provider()
mesh_prov.inputs.data_sources.Connect(my_data_sources)
mesh = mesh_prov.outputs.mesh.GetData()

#or 
model =dpf.Model(my_data_sources)
mesh = model.Mesh

#access elements scoping
my_elements_scoping = mesh.ElementScoping

#access nodes scoping
my_nodes_scoping = mesh.NodeScoping

#get connectivity (ordered node ids) of one element
my_el_1 = mesh.ElementById(1)
my_el_1.NodeIds
#connectivity with only primary (corner) nodes
my_el_1.CornerNodeIds 
#only secondary (mid side) nodes
my_el_1.MidNodeIds

#get coordinates
mesh.CoordinatesField #complete 3D field with scoping = mesh.NodesScoping
#or node by node
my_node_1 = mesh.NodeById(1)
my_node_1.X
my_node_1.Y
my_node_1.Z
from ansys.dpf import core as dpf

my_model = dpf.Model(my_data_sources)
mesh = my_model.metadata.meshed_region

#access elements scoping
my_elements_scoping = mesh.elements.scoping

#access nodes scoping
my_nodes_scoping = mesh.nodes.scoping

#get connectivity (ordered node ids) of one element
my_el_1 = mesh.elements.element_by_id(1)
my_el_1.node_ids
#element shape
my_el_1.element_shape #solid shell or beams

#get coordinates
mesh.nodes.coordinates_field #complete 3D field with scoping = mesh.nodes.scoping
#or node by node
my_node_1 = mesh.nodes.node_by_id(1)
my_node_1.coordinates #[x y z] coordinates 
#include "dpf_api.h"
#include "dpf_api_i.cpp"

ansys::dpf::Operator mesh_prov("MeshProvider");
mesh_prov.connect(ansys::dpf::eDataSourcesPin, my_data_sources);
ansys::dpf::MeshedRegion mesh = mesh_prov.getOutputMeshedRegion(0);

//access elements Scoping
ansys::dpf::Scoping my_elements_scoping = mesh.elementScoping();

//access nodes Scoping
ansys::dpf::Scoping my_nodes_scoping = mesh.nodeScoping();

//get connectivity(ordered node indices) of one element
ansys::dpf::PropertyField connectivity = mesh.connectivity();
ansys::dpf::PropFieldCursor cursor;
connectivity.fillCursor(0, cursor); // connectivity of the first element
connectivity.fillCursor(my_elements_scoping.indexById(1), cursor); // connectivity of the element of id 1
int* node_indices = cursor.data();
int num_nodes_in_elem = cursor.size();

//get coordinates
ansys::dpf::Field coordinates = mesh.nodesCoordinates();
ansys::dpf::FieldCursor fcursor;
coordinates.fillCursor(0, fcursor); // coordinates of the first node
coordinates.fillCursor(my_nodes_scoping.indexById(1), fcursor); // coordinates of the node of id 1
double* node_coord = fcursor.data();

//get element types
ansys::dpf::PropertyField element_types = mesh.elementTypes();
element_types.fillCursor(0, cursor); // element_types of the first element
element_types.fillCursor(my_elements_scoping.indexById(1), cursor); // element_types of the element of id 1
int element_type = *cursor.data();
ansys::dpf::ElementDescriptor element_des = ansys::dpf::elements::descriptor(element_type);
std::string name = element_des.name;
int num_nodes = element_des.number_of_nodes;
int num_corner_nodes = element_des.number_of_corner_nodes;
int num_sec_nodes = element_des.number_of_mid_nodes;
bool issolid = element_des.solid;

Time Freq Support

Create Time Freq Support

The time or frequency space of an analysis is described by the Time Freq Support entity in DPF. It gives access to real and imaginary sets. User can create a time freq support to manage data.

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

# 1. create a generic scoping from scratch
my_time_freq_support = dpf.TimeFreqSupport()

step_id = 1

# create the fields
# time_frequencies/complex_frequencies/harmonic_indices have TimeFreq_sets location 
# and their scoping have TimeFreq_steps location
time_frequencies = dpf.FieldsFactory.CreateScalarField(3, "TimeFreq_sets")
time_frequencies.Scoping.Ids = [step_id]
time_frequencies.Scoping.Location = "TimeFreq_steps"
time_frequencies.Data = [1.1, 1.2, 3.0]

rpms = dpf.FieldsFactory.CreateScalarField(1, "TimeFreq_steps")
rpms.Scoping.Ids = [step_id]
rpms.Data = [30.0]

harmonic_indices = dpf.FieldsFactory.CreateScalarField(2, "TimeFreq_sets")
harmonic_indices.Scoping.Ids = [step_id]
harmonic_indices.Scoping.Location = "TimeFreq_steps"
harmonic_indices.Data = [2.0, -1.0, 1.0]

# set time_freq_support data
my_time_freq_support.TimeFreqs = time_frequencies
my_time_freq_support.Rpms = rpms
my_time_freq_support.SetHarmonicIndices(harmonic_indices, 0)
from ansys.dpf import core as dpf

# Create a generic time_freq_support from scratch

# create time_freq_support object
my_time_freq_support = dpf.TimeFreqSupport()

step_id = 1

# create fields 
time_frequencies = dpf.Field(nature=dpf.natures.scalar, location=dpf.locations.time_freq)
time_frequencies.scoping.location = dpf.locations.time_freq_step
time_frequencies.append([0.1, 0.32, 0.4], step_id)
rpm = dpf.Field(nature=dpf.natures.scalar, location=dpf.locations.time_freq_steps)
rpm.append([ 30.0 ], step_id)
harmonic_indices = dpf.Field(nature=dpf.natures.scalar, location=dpf.locations.time_freq)
harmonic_indices.scoping.location = dpf.locations.time_freq_step
harmonic_indices.append([1.0, 2.0, -1.0], step_id)

# set the time_freq_support fields
my_time_freq_support.time_frequencies = time_frequencies
my_time_freq_support.rpms = rpm
# here we specify the stage number for cyclic harmonic indices.
my_time_freq_support.set_harmonic_indices(harmonic_indices, stage_num = 0)
#include "dpf_api.h"
#include "dpf_api_i.cpp"

// create time_freq_support from scratch
ansys::dpf::TimeFreqSupport time_freq_support; 

// create time_frequencies, rpms and harmonic indices field
ansys::dpf::Field time_freq(3, { 1 }, ansys::dpf::locations::time_set); 
time_freq.scoping().setIds({ 1, 2, 3 });
time_freq.scoping().setLocation(ansys::dpf::locations::time_step); 
time_freq.setData({ 0.1, 0.21, 0.2 });
ansys::dpf::Field rpms(1, { 1 }, ansys::dpf::locations::time_step);
rpms.scoping().setIds({ 1 });
rpms.setData({ 30 });
ansys::dpf::Field harmonic_indices(0, { 1 }, ansys::dpf::locations::time_set);
harmonic_indices.scoping().setIds({ 1, 2, 3 });
harmonic_indices.scoping().setLocation(ansys::dpf::locations::time_step);
harmonic_indices.setData({ 1.0, 2.0, -1.0 }); 

// set the time_freq_support fields
time_freq_support.setTimeFrequencies(time_freq); 
time_freq_support.setRpms(rpms); 
time_freq_support.setHarmonicIndices(harmonic_indices); 

// set harmonic indices for a specific cyclic stage number
ansys::dpf::Field harmonic_indices_2(3, { 1 }, ansys::dpf::locations::time_set);
harmonic_indices_2.scoping().setIds({ 1, 2, 3 });
harmonic_indices_2.setData({ 1.0, 3.0, 2.0 });
time_freq_support.setHarmonicIndices(harmonic_indices_2, 2); // set indices for the second stage

Get Time Freq Support's data from DataSources

Time Freq Support of a specific file can be accessed using the following methods.

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

time_freq_prov = ops.metadata.time_freq_provider()
time_freq_prov.inputs.data_sources.Connect(my_data_sources)
time_freq = time_freq_prov.outputs.time_freq_support.GetData()

#or
time_freq = dpf.Model(my_path).TimeFreqSupport

#get number of time/freq sets
time_freq.NumberSets

#get field of real time freqs
my_time_freq_field = time_freq.TimeFreqs
my_time_freq_field.Unit #usually s or Hz
#get time or freqs on the first load step
my_time_freq_field.GetEntityDataById(1)

#get field of imaginary time freqs
my_im_time_freq_field = time_freq.ImaginaryFreqs
from ansys.dpf import core as dpf

my_model = dpf.Model(my_data_sources)
time_freq = my_model.metadata.time_freq_support

#get number of time/freq sets
time_freq.n_sets

#get field of real time freqs
my_time_freq_field = time_freq.frequencies
my_time_freq_field.unit #usually s or Hz
#get time or freqs on the first load step
my_time_freq_field.get_entity_data_by_id(1)

#get field of imaginary time freqs
my_im_time_freq_field = time_freq.complex_frequencies
#include "dpf_api.h"
#include "dpf_api_i.cpp"

ansys::dpf::Operator time_freq_prov("TimeFreqSupportProvider");
time_freq_prov.connect(ansys::dpf::eDataSourcesPin, my_data_sources);
ansys::dpf::TimeFreqSupport time_freq = time_freq_prov.getOutputTimeFreqSupport(0);

//get number of time/freq sets
int num_sets = time_freq.numberOfSets();

//get Field of real time freqs
ansys::dpf::Field my_time_freq_field = time_freq.frequencies();
ansys::dpf::Unit time_freq_unit = my_time_freq_field.fieldDefinition().unit(); //usually s or Hz

//get time or freqs on the first load step
int size;
double* freqs = my_time_freq_field.entityDataById(1, size);

Model

Explore a Model

The Model is built with DataSources that it will open (in a streams by default) to explore an analysis. Printing the model is a good tool to see the results that are available.

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

my_data_sources = dpf.DataSources(my_path)

#create the model
my_model = dpf.Model(my_path)
#or
my_model = dpf.Model(my_data_sources)

#explore
print(my_model)
time_freq_support = my_model.TimeFreqSupport
meshed_region = my_model.Mesh
result_info = my_model.ResultInfo

#instanciate result provider
#those providers are automatically connected to the streams
displacement = my_model.results.displacement()
stress = my_model.results.stress()

#choose the time freq for the providers
stress.inputs.time_scoping.Connect(time_freq_support.GetTimeFreq(1))
from ansys.dpf import core as dpf

my_data_sources = dpf.DataSources(my_path)

#create the model
my_model = dpf.Model(my_data_sources)
#or
my_model = dpf.Model(my_path)

#explore
print(my_model)
time_freq_support = my_model.metadata.time_freq_support
meshed_region = my_model.metadata.meshed_region
result_info = my_model.metadata.result_info

#instanciate result provider
#those providers are automatically connected to the streams
displacement = my_model.results.displacement()
stress = my_model.results.stress()

#choose the time freq for the providers
stress.inputs.time_scoping.connect(time_freq_support.get_cumulative_index(1,1))
#include "dpf_api.h"
#include "dpf_api_i.cpp"
#include "helpers/dpf_result.h"
#include "helpers/dpf_model.h"


ansys::dpf::DataSources my_data_sources(my_path);

//create the model
ansys::dpf::Model my_model(my_data_sources);
//or
ansys::dpf::Model my_model(my_path);

//explore
ansys::dpf::TimeFreqSupport time_freq_support = my_model.getTimeFreqSupport();
ansys::dpf::MeshedRegion meshed_region = my_model.getMesh();
ansys::dpf::ResultInfo result_info = my_model.getResultInfo();

//instantiate result provider
//those providers are automatically connected to the streams
ansys::dpf::Result displacement = my_model.CreateResultEvaluationWorkflow("U");
ansys::dpf::Result stress = my_model.CreateResultEvaluationWorkflow("S");

//choose the time freq for the providers
ansys::dpf::DpfError error;
ansys::dpf::FieldsContainer fields = displacement.EvaluateAtGivenTime(0.0, error);

Using DPF's operators in scripting

Operator types

In DPF, the operator is used to import and modify the simulation data. We can count 3 main types of operators:

  • Operators importing/reading data

  • Operators transforming existing data

  • Operators exporting data

Operators importing / reading data

Those operators allow to read data from solver files or from standard file types. Different solver format are handled by DPF like rst/mode/rfrq/rdsp.. for MAPDL, d3plot for LsDyna, cas.h5/dat.h5/res/flprj for CFX and Fluent, odb for Abaqus... To read those, different readers have been implemented in plugins. Plugins can be loaded on demand in any dpf's scripting language with the "load library" methods. File readers can be used generically thanks to dpf's result providers, which means that the same operators can be used for any file types. For example, reading a displacement or a stress for any files will be done with:

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

my_file_path = r"C:/temp/file.rst"
#or ...
my_file_path = r"C:/temp/d3plot"

my_data_sources = dpf.DataSources(my_file_path, "rst")
#or ...
my_data_sources = dpf.DataSources(my_file_path, "d3plot")

#displacement for any solver file
u_op = ops.result.displacement() 
u_op.inputs.data_sources.Connect(my_data_sources) 
my_u = u_op.outputs.fields_container.GetData()

#stress for any solver file
s_op = ops.result.stress() 
s_op.inputs.data_sources.Connect(my_data_sources) 
my_s = s_op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf
from ansys.dpf.core import operators as ops

my_file_path = r"C:/temp/file.rst"
#or ...
my_file_path = r"C:/temp/d3plot"

my_data_sources = dpf.DataSources(my_file_path)
#or ...
my_data_sources = dpf.DataSources()
my_data_sources.set_result_file_path(my_file_path, "d3plot")

#displacement for any solver file
u_op = ops.result.displacement()
u_op.inputs.data_sources.connect(my_data_sources) 
my_u = u_op.outputs.fields_container()

#stress for any solver file
s_op = ops.result.stress() 
s_op.inputs.data_sources.connect(my_data_sources) 
my_s = s_op.outputs.fields_container()
#include "dpf_api.h"
#include "dpf_api_i.cpp"

std::string my_path = "c:/temp/file.rst"
//or
std::string my_path = "c:/temp/d3plot"

ansys::dpf::DataSources my_data_sources;
my_data_sources.addResultFile(my_path, "rst");
//or
my_data_sources.addResultFile(my_path, "d3plot");

//displacement for any solver file
ansys::dpf::Operator u_op("U");
u_op.connect(ansys::dpf::eDataSourcesPin, my_data_sources);
ansys::dpf::FieldsContainer my_u = u_op.getOutputFieldsContainer(0);


//stress for any solver file
ansys::dpf::Operator s_op("S");
s_op.connect(ansys::dpf::eDataSourcesPin, my_data_sources);
ansys::dpf::FieldsContainer my_s = s_op.getOutputFieldsContainer(0);

Result providers can be customized to read a specific time frequency or to provide results on a subset of the mesh:

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

my_file_path = r"C:/temp/file.rst"
my_model = dpf.Model(my_file_path)

#print the time freq support to see available time/frequencies
print(my_model.TimeFreqSupport)

#displacement for any solver file
u_op = my_model.results.displacement() 

# Different ways to set the time scoping
# Select one time/frequency
u_op.inputs.time_scoping.Connect(2) # Int : Select second time/freq set in the time freq support
u_op.inputs.time_scoping.Connect(0.002) # Double : Gives a field interpolated at the given time/freq value


# Select multiple times/frequencies 
time_sets =[1,2,3]
u_op.inputs.time_scoping.Connect(time_sets) # Array Int: Select time/freq sets in the time freq support
times = [0.002, 0.003]
u_op.inputs.time_scoping.Connect(times) # Array Double : Gives fields interpolated at the given time/freq values
 
# Select all the time/frequencies of a load step
load_step =dpf.TimeFreqScopingFactory.ScopingByLoadStep(2)
u_op.inputs.time_scoping.Connect(load_step)


# Choose the mesh scoping
node_scoping = dpf.MeshScopingFactory.NodalScoping(range(0,100))
u_op.inputs.mesh_scoping.Connect(node_scoping)

element_scoping = dpf.MeshScopingFactory.ElementalScoping(range(0,100))
u_op.inputs.mesh_scoping.Connect(element_scoping)
 

my_u = u_op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf

my_file_path = r"C:/temp/file.rst"
my_model = dpf.Model(my_file_path)

#print the time freq support to see available time/frequencies
print(my_model.metadata.time_freq_support)


#displacement for any solver file
u_op = my_model.results.displacement() 


# Different ways to set the time scoping
# Select one time/frequency
u_op.inputs.time_scoping.connect(2) # Int : Select second time/freq set in the time freq support
u_op.inputs.time_scoping.connect(0.002) # Double : Gives a field interpolated at the given time/freq value


# Select multiple times/frequencies 
time_sets =[1,2,3]
u_op.inputs.time_scoping.connect(time_sets) # Array Int: Select time/freq sets in the time freq support
times = [0.002, 0.003]
u_op.inputs.time_scoping.connect(times) # Array Double : Gives fields interpolated at the given time/freq values
 
# Select all the time/frequencies of a load step
load_step =dpf.Scoping(ids=[2],location=dpf.locations.time_freq_step)
u_op.inputs.time_scoping.connect(load_step)


# Choose the mesh scoping
node_scoping = dpf.Scoping(ids = range(0,100), location = dpf.locations.nodal)
u_op.inputs.mesh_scoping.connect(node_scoping)

element_scoping = dpf.Scoping(ids = range(0,100), location = dpf.locations.elemental)
u_op.inputs.mesh_scoping.connect(element_scoping)
 
 
my_u = u_op.outputs.fields_container()
#include "dpf_api.h"
#include "dpf_api_i.cpp"

std::string my_path = "c:/temp/file.rst"
//or
std::string my_path = "c:/temp/d3plot"

ansys::dpf::DataSources my_data_sources;
my_data_sources.addResultFile(my_path, "rst");
//or
my_data_sources.addResultFile(my_path, "d3plot");

//displacement for any solver file
ansys::dpf::Operator u_op("U");
u_op.connect(ansys::dpf::eDataSourcesPin, my_data_sources);


/// Different ways to set the time scoping
// Select one time/frequency
u_op.connect(ansys::dpf::eTimeScopPin, 2); // Int : Select second time/freq set in the time freq support
u_op.connect(ansys::dpf::eTimeScopPin, 0.002); // Double : Gives a field interpolated at the given time/freq value


// Select multiple times/frequencies 
std::vector<int> time_sets = { 1,2,3 };
u_op.connect(ansys::dpf::eTimeScopPin, time_sets); // Vec Int: Select time/freq sets in the time freq support
std::vector<double> times = { 0.002, 0.003 };
u_op.connect(ansys::dpf::eTimeScopPin, times); // Vec Double : Gives fields interpolated at the given time/freq values
 
// Select all the time/frequencies of a load step
ansys::dpf::Scoping load_step({ 2 }, ansys::dpf::locations::time_step);
u_op.connect(ansys::dpf::eTimeScopPin, load_step);



/// Choose the mesh scoping
ansys::dpf::Scoping node_scoping({1,2,3}, ansys::dpf::locations::nodal);
u_op.connect(ansys::dpf::eMeshScopPin, node_scoping);


ansys::dpf::Scoping element_scoping({1,2,3}, ansys::dpf::locations::elemental);
u_op.connect(ansys::dpf::eMeshScopPin, element_scoping);

 
ansys::dpf::FieldsContainer my_u = u_op.getOutputFieldsContainer(0);

Standards file formats reader are also supported to import custom data. Fields can be imported from csv, vtk or hdf5 files:

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

my_file_path = r"C:/temp/file.csv"
my_data_sources = dpf.DataSources(my_file_path)

csv = ops.serialization.csv_to_field()
csv.inputs.data_sources.Connect(my_data_sources)
my_fields = csv.outputs.fields_container.GetData()
from ansys.dpf import core as dpf
from ansys.dpf.core import operators as ops

my_file_path = r"C:/temp/file.csv"
my_data_sources = dpf.DataSources(my_file_path)
csv = ops.serialization.csv_to_field()
csv.inputs.data_sources.connect(my_data_sources)
my_fields = csv.outputs.fields_container()
#include "dpf_api.h"
#include "dpf_api_i.cpp"

std::string my_path = "c:/temp/file.csv"
ansys::dpf::DataSources my_data_sources;
my_data_sources.addResultFile(my_path);

ansys::dpf::Operator csv("csv_to_field");
csv.connect(ansys::dpf::eDataSourcesPin, my_data_sources);
ansys::dpf::FieldsContainer my_fields = csv.getOutputFieldsContainer(0);
version,0,,,,,
analysis,static,,,,,
num_sets,10,,,,,
storage_type,0,,,,,
unit,Pa,,,,,
dim,sym matrix,3,3,,,
location,Nodal,,,,,
shellLayer,0,,,,,
,,,,,,
,,,,,,
,step,sub_step,cumulative_index,,,
set,1,1,1,,,
,SXX,SYY,SZZ,SXY,SYZ,SXZ
Scoping,,,,,,
1,1.00E+00,1.00E+00,1.00E+00,1.00E+00,1.00E+00,1.00E+00
2,1.00E+00,1.00E+00,1.00E+00,1.00E+00,1.00E+00,1.00E+00
3,1.00E+00,1.00E+00,1.00E+00,1.00E+00,1.00E+00,1.00E+00
end_of_set,,,,,,
,step,sub_step,cumulative index,,,
set,1,2,2,,,
,SXX,SYY,SZZ,SXY,SYZ,SXZ
Scoping,,,,,,
1,2.00E+00,2.00E+00,2.00E+00,2.00E+00,2.00E+00,2.00E+00
2,2.00E+00,2.00E+00,2.00E+00,2.00E+00,2.00E+00,2.00E+00
3,2.00E+00,2.00E+00,2.00E+00,2.00E+00,2.00E+00,2.00E+00
end_of_set,,,,,,

Operators transforming existing data

The field being the main data container in DPF, most of the operator transforming the data take a field or fields container in input and return a transformed field or fields container in output. Analytic, averaging or filtering operations can be performed on the simulation data:

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

field1 = dpf.FieldsFactory.Create3DVectorField(3)
field1.Data = [1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0]
field1.Scoping.Ids = [1,2,3]
field1.Unit = "m"


#example 1 analytic operator: scale operator
op1 = ops.math.scale()
op1.inputs.field.Connect(field1)
op1.inputs.ponderation.Connect(2.0)
out = op1.outputs.getfield()
out.Data
# returns:
# [2, 4, 6, 8, 10, 12, 14, 16, 18]

#example 2 filtering operator
op2 = ops.filter.field_high_pass()
op2.inputs.field.Connect(field1)
op2.inputs.threshold.Connect(3.0)
out = op2.outputs.getfield()
out.Data
# returns:
# [4, 5, 6, 7, 8, 9]

out.Scoping.Ids
# returns:
# [2, 3]
from ansys.dpf import core as dpf
from ansys.dpf.core import operators as ops

field1 = dpf.Field(nentities=3)
field1.data = [1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0]
field1.scoping.ids = [1,2,3]
field1.unit = "m"

#example 1 analytic operator: scale operator
op1 = ops.math.scale()
op1.inputs.field.connect(field1)
op1.inputs.ponderation.connect(2.0)
out = op1.outputs.field()
out.data
# returns:
# [[ 2.,  4.,  6.], [ 8., 10., 12.], [14., 16., 18.]]

#example 2 filtering operator
op2 = ops.filter.field_high_pass()
op2.inputs.field.connect(field1)
op2.inputs.threshold.connect(3.0)
out = op2.outputs.field()
out.data
# returns:
# [[4., 5., 6.], [7., 8., 9.]]

out.scoping.ids
# returns:
# [2, 3]
#include "dpf_api.h"
#include "dpf_api_i.cpp"


ansys::dpf::Field field1(3, { 3 }, ansys::dpf::locations::nodal);
field1.setData({1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0});
field1.scoping().setIds({ 1,2,3 });

//example 1 analytic operator: scale operator
ansys::dpf::Operator op1("scale");
op1.connect(0,field1);
op1.connect(1,2.0);
ansys::dpf::Field out = op1.getOutputField(0);
int size=0;
ansys::dpf::dp_double*const data = out.data(size);
// returns:
// { 2.,  4.,  6., 8., 10., 12., 14., 16., 18.}

// example 2 filtering operator
ansys::dpf::Operator op2("core::field::high_pass");
op2.connect(0,field1);
op2.connect(1,3.0);
out = op2.getOutputField(0);
ansys::dpf::dp_double*const data2 = out.data(size);
// returns:
// {4., 5., 6., 7., 8., 9.}

Operators exporting data

After transforming or reading simulation data with DPF, the user might want to export the results in a given format to use it in another environment or to save it for future use with dpf. Vtk, h5, csv and txt (serializer operator) are examples of supported exports. Export operators often match with import operators allowing user to reuse their data. The "serialization" operators menu lists the available import/export operators.

Example of usage
#example import/export vtk file
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

my_file_path = r"C:/temp/file.vtk"
my_model = dpf.Model(my_file_path)

#search available results in the file
print(my_model.ResultInfo.Results[2].Name)
#return:
#displacement_mode_6

my_u_op = ops.serialization.vtk_to_fields()
my_u_op.inputs.field_name.Connect(my_model.ResultInfo.Results[2].Name)
my_u_op.inputs.data_sources.Connect(my_model.DataSources)
my_u = my_u_op.outputs.getfields_container()

#scale it by 2.0
my_scale_op = ops.math.scale_fc()
my_scale_op.inputs.fields_container.Connect(my_u)
my_scale_op.inputs.ponderation.Connect(2.0)

#export the result in vtk
my_export = ops.serialization.vtk_export()
my_export.inputs.file_path.Connect(r"C:/temp/fileNew.vtk")
my_export.inputs.fields1.Connect(my_scale_op.outputs.fields_container)
my_export.inputs.mesh.Connect(my_model.Mesh)
my_export.Run()


#example import/export vtk file
from ansys.dpf import core as dpf
from ansys.dpf.core import operators as ops

my_file_path = r"C:/temp/file.vtk"
my_model = dpf.Model(my_file_path)

#search available results in the file
result_info = my_model.metadata.result_info
print(result_info.available_results[2].name)
#return:
#displacement_mode_6

my_u_op = ops.serialization.vtk_to_fields()
my_u_op.inputs.field_name.connect(result_info.available_results[2].name)
my_u_op.inputs.data_sources.connect(my_model.DataSources)
my_u = my_u_op.outputs.fields_container()

#scale it by 2.0
my_scale_op = ops.math.scale_fc()
my_scale_op.inputs.fields_container.connect(my_u)
my_scale_op.inputs.ponderation.connect(2.0)

#export the result in vtk
my_export = ops.serialization.vtk_export()
my_export.inputs.file_path.connect(r"C:/temp/fileNew.vtk")
my_export.inputs.fields1.connect(my_scale_op.outputs.fields_container)
my_export.inputs.mesh.connect(my_model.metadata.meshed_region)
my_export.run()
#include "dpf_api.h"
#include "dpf_api_i.cpp"

//example import/export vtk file

std::string my_path = "c:/temp/file.vtk"
ansys::dpf::DataSources my_data_sources;
my_data_sources.addResultFile(my_path);

ansys::dpf::Operator my_u_op("vtk::vtk::FieldProvider");
my_u_op.connect(ansys::dpf::eDataSourcesPin, my_data_sources);
my_u_op.connect(0, "displacement_mode_6"); // name of the field in the vtk file
ansys::dpf::FieldsContainer my_fields = my_u_op.getOutputFieldsContainer(0);

//scale it by 2.0
ansys::dpf::Operator my_scale_op("scale_fc");
my_scale_op.connect(0,my_fields);
my_scale_op.connect(1,2.0);

//get the mesh
ansys::dpf::Operator my_mesh_op("MeshProvider");
my_mesh_op.connect(ansys::dpf::eDataSourcesPin, my_data_sources);

//export the result in vtk
ansys::dpf::Operator my_export("vtk_export");
my_export.connect(0, std::string("C:/temp/fileNew.vtk"));
my_export.connect(1, my_mesh_op, 0);
my_export.connect(2, my_scale_op, 0);
my_export.run();
# vtk DataFile Version 2.0
DummyMesh output
ASCII
DATASET UNSTRUCTURED_GRID
POINTS 155 double
5 0 -5
5 0 -10
5 0 -15
10 0 -5
10 0 -10
10 0 -15
15 0 -5
15 0 -10
15 0 -15
15 1.54 -15
15 1.54 -10
15 1.54 -5
10 1.54 -15
10 1.54 -10
10 1.54 -5
5 1.54 -15
5 1.54 -10
5 1.54 -5
20 1.54 -5
20 1.54 -10
20 1.54 -15
20 1.54 -20
15 1.54 -20
10 1.54 -20
5 1.54 -20
0 1.54 -20
0 1.54 -15
0 1.54 -10
0 1.54 -5
0 1.54 0
5 1.54 0
10 1.54 0
15 1.54 0
20 1.54 0
15 0 0
10 0 0
5 0 0
20 0 0
0 0 0
0 0 -5
0 0 -10
0 0 -15
0 0 -20
5 0 -20
10 0 -20
15 0 -20
20 0 -20
20 0 -15
20 0 -10
20 0 -5
5 0 -7.5
7.5 0 -5
5 0.77 -5
5 0 -2.5
2.5 0 -5
5 0 -12.5
7.5 0 -10
5 0.77 -10
2.5 0 -10
7.5 0 -15
5 0.77 -15
2.5 0 -15
5 0 -17.5
10 0 -7.5
12.5 0 -5
10 0.77 -5
10 0 -2.5
10 0 -12.5
12.5 0 -10
10 0.77 -10
12.5 0 -15
10 0.77 -15
10 0 -17.5
15 0 -7.5
15 0.77 -5
15 0 -2.5
17.5 0 -5
15 0 -12.5
15 0.77 -10
17.5 0 -10
15 0.77 -15
15 0 -17.5
17.5 0 -15
15 1.54 -12.5
12.5 1.54 -15
17.5 1.54 -15
15 1.54 -17.5
15 1.54 -7.5
12.5 1.54 -10
17.5 1.54 -10
12.5 1.54 -5
17.5 1.54 -5
15 1.54 -2.5
10 1.54 -12.5
7.5 1.54 -15
10 1.54 -17.5
10 1.54 -7.5
7.5 1.54 -10
7.5 1.54 -5
10 1.54 -2.5
5 1.54 -12.5
5 1.54 -17.5
2.5 1.54 -15
5 1.54 -7.5
2.5 1.54 -10
2.5 1.54 -5
5 1.54 -2.5
20 1.54 -7.5
20 1.54 -2.5
20 0.77 -5
20 1.54 -12.5
20 0.77 -10
20 1.54 -17.5
20 0.77 -15
17.5 1.54 -20
20 0.77 -20
12.5 1.54 -20
15 0.77 -20
7.5 1.54 -20
10 0.77 -20
2.5 1.54 -20
5 0.77 -20
0 1.54 -17.5
0 0.77 -20
0 1.54 -12.5
0 0.77 -15
0 1.54 -7.5
0 0.77 -10
0 1.54 -2.5
0 0.77 -5
2.5 1.54 0
0 0.77 0
7.5 1.54 0
5 0.77 0
12.5 1.54 0
10 0.77 0
17.5 1.54 0
15 0.77 0
20 0.77 0
12.5 0 0
17.5 0 0
7.5 0 0
2.5 0 0
20 0 -2.5
0 0 -2.5
0 0 -7.5
0 0 -12.5
0 0 -17.5
2.5 0 -20
7.5 0 -20
12.5 0 -20
17.5 0 -20
20 0 -17.5
20 0 -12.5
20 0 -7.5

CELLS   16 336
20 2 43 42 41 15 24 25 26 62 148 147 61 101 120 122 102 60 121 123 125 
20 2 5 44 43 15 12 23 24 59 72 149 62 94 95 118 101 60 71 119 121 
20 1 2 41 40 16 15 26 27 55 61 146 58 100 102 124 104 57 60 125 127 
20 1 4 5 2 16 13 12 15 56 67 59 55 97 93 94 100 57 69 71 60 
20 0 1 40 39 17 16 27 28 50 58 145 54 103 104 126 105 52 57 127 129 
20 0 3 4 1 17 14 13 16 51 63 56 50 98 96 97 103 52 65 69 57 
20 0 39 38 36 17 28 29 30 54 144 142 53 105 128 130 106 52 129 131 133 
20 0 36 35 3 17 30 31 14 53 141 66 51 106 132 99 98 52 133 135 65 
20 5 8 45 44 12 9 22 23 70 81 150 72 84 86 116 95 71 80 117 119 
20 8 47 46 45 9 20 21 22 82 152 151 81 85 112 114 86 80 113 115 117 
20 4 7 8 5 13 10 9 12 68 77 70 67 88 83 84 93 69 78 80 71 
20 7 48 47 8 10 19 20 9 79 153 82 77 89 110 85 83 78 111 113 80 
20 3 6 7 4 14 11 10 13 64 73 68 63 90 87 88 96 65 74 78 69 
20 6 49 48 7 11 18 19 10 76 154 79 73 91 107 89 87 74 109 111 78 
20 3 35 34 6 14 31 32 11 66 139 75 64 99 134 92 90 65 135 137 74 
20 6 34 37 49 11 32 33 18 75 140 143 76 92 136 108 91 74 137 138 109 
CELL_TYPES 16
25
25
25
25
25
25
25
25
25
25
25
25
25
25
25
25
CELL_DATA	16
SCALARS element_id double 1
LOOKUP_TABLE  default
4
3
8
7
12
11
16
15
2
1
6
5
10
9
14
13
POINT_DATA	155
SCALARS node_id double 1
LOOKUP_TABLE  default
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
VECTORS displacement_mode_6 double
51.2993 412.185 -51.2993
70.308 635.478 -1.02908e-11
51.2993 412.185 51.2993
5.10251e-12 635.478 -70.308
8.78623e-12 977.298 -1.82319e-11
7.02596e-12 635.478 70.308
-51.2993 412.185 -51.2993
-70.308 635.478 -1.57278e-11
-51.2993 412.185 51.2993
79.1878 414.682 -79.1878
118.474 641.778 7.99345e-12
79.1878 414.682 79.1878
-1.16515e-12 641.778 -118.474
-2.89414e-12 987.86 8.79527e-12
2.25046e-12 641.778 118.474
-79.1878 414.682 -79.1878
-118.474 641.778 3.84059e-12
-79.1878 414.682 79.1878
81.72 1.78526 27.0229
126.372 7.65984 4.87715e-12
81.72 1.78526 -27.0229
20.9839 -11.7307 -20.9839
27.0229 1.78526 -81.72
-2.23115e-12 7.65984 -126.372
-27.0229 1.78526 -81.72
-20.9839 -11.7307 -20.9839
-81.72 1.78526 -27.0229
-126.372 7.65984 2.37022e-12
-81.72 1.78526 27.0229
-20.9839 -11.7307 20.9839
-27.0229 1.78526 81.72
-1.07196e-12 7.65984 126.372
27.0229 1.78526 81.72
20.9839 -11.7307 20.9839
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
61.2462 578.397 -31.8987
31.8987 578.397 -61.2462
-14.6188 415.819 14.6188
18.0367 194.204 -41.7448
41.7448 194.204 -18.0367
61.2462 578.397 31.8987
45.4351 896.775 -1.17697e-11
-25.1058 643.415 -3.18767e-12
59.9718 305.08 -2.83048e-12
31.8987 578.397 61.2462
-14.6188 415.819 -14.6188
41.7448 194.204 18.0367
18.0367 194.204 41.7448
4.72319e-12 896.775 -45.4351
-31.8987 578.397 -61.2462
3.66352e-12 643.415 25.1058
6.77309e-13 305.08 -59.9718
7.03301e-12 896.775 45.4351
-45.4351 896.775 -1.50305e-11
3.20963e-12 991.563 -4.89835e-12
-31.8987 578.397 61.2462
2.73432e-12 643.415 -25.1058
2.5882e-12 305.08 59.9718
-61.2462 578.397 -31.8987
14.6188 415.819 14.6188
-18.0367 194.204 -41.7448
-41.7448 194.204 -18.0367
-61.2462 578.397 31.8987
25.1058 643.415 -3.8753e-12
-59.9718 305.08 -6.71046e-12
14.6188 415.819 -14.6188
-18.0367 194.204 41.7448
-41.7448 194.204 18.0367
102.75 578.165 -44.408
44.408 578.165 -102.75
95.0316 188.958 -33.3158
33.3158 188.958 -95.0316
102.75 578.165 44.408
67.315 892.384 5.43093e-12
146.619 295.876 1.42573e-12
44.408 578.165 102.75
95.0316 188.958 33.3158
33.3158 188.958 95.0316
3.70803e-14 892.384 -67.315
-44.408 578.165 -102.75
1.51405e-12 295.876 -146.619
2.67229e-12 892.384 67.315
-67.315 892.384 2.31699e-12
-44.408 578.165 102.75
2.33408e-12 295.876 146.619
-102.75 578.165 -44.408
-33.3158 188.958 -95.0316
-95.0316 188.958 -33.3158
-102.75 578.165 44.408
-146.619 295.876 -8.05141e-13
-95.0316 188.958 33.3158
-33.3158 188.958 95.0316
115.954 3.41071 14.8077
38.2157 0.602202 22.5885
37.848 -1.26373 14.0564
115.954 3.41071 -14.8077
59.255 0.377486 2.03251e-12
38.2157 0.602202 -22.5885
37.848 -1.26373 -14.0564
22.5885 0.602202 -38.2157
11.2766 -6.40131 -11.2766
14.8077 3.41071 -115.954
14.0564 -1.26373 -37.848
-14.8077 3.41071 -115.954
-9.01886e-13 0.377486 -59.255
-22.5885 0.602202 -38.2157
-14.0564 -1.26373 -37.848
-38.2157 0.602202 -22.5885
-11.2766 -6.40131 -11.2766
-115.954 3.41071 -14.8077
-37.848 -1.26373 -14.0564
-115.954 3.41071 14.8077
-59.255 0.377486 8.94439e-13
-38.2157 0.602202 22.5885
-37.848 -1.26373 14.0564
-22.5885 0.602202 38.2157
-11.2766 -6.40131 11.2766
-14.8077 3.41071 115.954
-14.0564 -1.26373 37.848
14.8077 3.41071 115.954
-3.82181e-13 0.377486 59.255
22.5885 0.602202 38.2157
14.0564 -1.26373 37.848
11.2766 -6.40131 11.2766
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0

Chaining operators together

To create more complex operations and customizable results, operators can be chained together to create workflows. This way a result can be read from a solver result file and directly transformed in a single workflow. Examples can be found in APIs/Workflow examples menu. 2 syntaxes can be used to create and connect operators together:

Example of usage
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

my_file_path = r"C:/temp/file.rst"
my_data_sources = dpf.DataSources(my_file_path)

#using input pins
u_op = ops.result.displacement() 
u_op.inputs.data_sources.Connect(my_data_sources)

norm_op = ops.math.norm_fc()
norm_op.inputs.fields_container.Connect(u_op.outputs.fields_container)

my_u_norm = norm_op.outputs.fields_container.GetData()

#using expression to create the workflow in a single line
#pins are directly connected in the constructor (input pins syntax can still be used)
norm_op = ops.math.norm_fc(ops.result.displacement(data_sources=my_data_sources))
my_u_norm = norm_op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf
from ansys.dpf.core import operators as ops

my_file_path = r"C:/temp/file.rst"
my_data_sources = dpf.DataSources(my_file_path)

#using input pins
u_op = ops.result.displacement() 
u_op.inputs.data_sources.connect(my_data_sources)

norm_op = ops.math.norm_fc()
norm_op.inputs.fields_container.connect(u_op.outputs.fields_container)

my_u_norm = norm_op.outputs.fields_container()

#using expression to create the workflow in a single line
#pins are directly connected in the constructor (input pins syntax can still be used)
norm_op = ops.math.norm_fc(ops.result.displacement(data_sources=my_data_sources))
my_u_norm = norm_op.outputs.fields_container()
#include "dpf_api.h"
#include "dpf_api_i.cpp"

std::string my_path = "c:/temp/file.rst"
ansys::dpf::DataSources my_data_sources;
my_data_sources.addResultFile(my_path);

ansys::dpf::Operator u_op("U");
u_op.connect(ansys::dpf::eDataSourcesPin, my_data_sources);

ansys::dpf::Operator norm_op("norm_fc");
norm_op.connect(0, u_op, 0); //connect norm_op input pin 0 to u_op output pin 0
 
ansys::dpf::FieldsContainer my_u_norm = norm_op.getOutputFieldsContainer(0);

Configurating operators

Advanced user might want to configurate an operator's behavior during its running phase. This can be done through the "config". This option allows to choose if an operator can directly modify the input data container instead of creating a new one with the "inplace" configuration, to choose if an operation between to fields should use their indices or mesh ids with the "work_by_index" configuration... Each operator's description explains which configuration are supported.

Example of usage
#use config for add operator
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

field1 = dpf.FieldsFactory.Create3DVectorField(3)
field1.Data = [1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0]
field1.Scoping.Ids = [1,2,3]
field1.Unit = "m"

field2 = dpf.FieldsFactory.Create3DVectorField(3)
field2.Data = [1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0]
field2.Scoping.Ids = [3,4,5]
field2.Unit = "m"

config = ops.math.add.defaultConfig
#or 
#config = dpf.OperatorConfig("add")

print(config) #print current values of configurations
# returns: 
#Available configurations:
         # binary_operation:1
         # mutex:false
         # permissive:false
         # run_in_parallel:true
         # use_cache:true
         # work_by_index:false


#modify work_by_index config (default is false)
config.work_by_index=True

#instanciate the operator with the config
op1 = ops.math.add(field1, field2,config=config)
out = op1.outputs.getfield()
out.Data
# returns:
# [ 2.,  4.,  6., 8., 10., 12., 14., 16., 18.]

#use default config value
config.work_by_index=False
op1 = ops.math.add(field1, field2, config=config)
out = op1.outputs.getfield() 
out.Data
# returns:
# [ 1.,  2.,  3., 4.,  5.,  6., 8., 10., 12., 4.,  5.,  6., 7.,  8.,  9.]

# changing the "permissive" config could allow to add fields of different homogeneities
# changing the "binary_operation" config could allow to keep only the intersection between fields ids and not the union
#...
#use config for add operator
from ansys.dpf import core as dpf
from ansys.dpf.core import operators as ops

field1 = dpf.Field(nentities=3)
field1.data = [1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0]
field1.scoping.ids = [1,2,3]
field1.unit = "m"

field2 = dpf.Field(nentities=3)
field2.data = [1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0]
field2.scoping.ids = [3,4,5]
field2.unit = "m"

config = ops.math.add.default_config()
#or 
config = dpf.Operator.default_config("add")

print(config.options) #print current values of configurations
# returns: 
#{'binary_operation': Ƈ', 'mutex': 'false', 'permissive': 'false', 'run_in_parallel': 'true', 'use_cache': 'true', 'work_by_index': 'false'}

print(config.config_option_documentation("work_by_index")) #print documentation for work by index
# returns: 
#If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

#modify work_by_index config (default is false)
config.set_work_by_index_option(True) 

#instanciate the operator with the config
op1 = ops.math.add(field1, field2, config=config)
out = op1.outputs.field() 
out.data
# returns:
# [[ 2.,  4.,  6.], [ 8., 10., 12.], [14., 16., 18.]]

#use default config value
config.set_work_by_index_option(False) 
op1 = ops.math.add(field1, field2, config=config)
out = op1.outputs.field() 
out.data
# returns:
# [[ 1.,  2.,  3.], [ 4.,  5.,  6.], [ 8., 10., 12.],  [ 4.,  5.,  6.], [ 7.,  8.,  9.]]

# changing the "permissive" config could allow to add fields of different homogeneities
# changing the "binary_operation" config could allow to keep only the intersection between fields ids and not the union
#...
//use config for add operator

#include "dpf_api.h"
#include "dpf_api_i.cpp"


ansys::dpf::Field field1(3, { 3 }, ansys::dpf::locations::nodal);
field1.setData({1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0});
field1.scoping().setIds({ 1,2,3 });

ansys::dpf::Field field2(3, { 3 }, ansys::dpf::locations::nodal);
field2.setData({1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0});
field2.scoping().setIds({ 3,4,5 });

ansys::dpf::OperatorConfig config = ansys::dpf::core::defaultOperatorConfig("add");

bool current_value = config.getBoolValue("work_by_index");//returns current values of configuration

//modify work_by_index config (default is false)
config.set("work_by_index", true);


//instantiate the operator with the config
ansys::dpf::Operator op1("add", config);
op1.connect(0,field1);
op1.connect(1,field2);
ansys::dpf::Field out = op1.getOutputField(0);
int size=0;
ansys::dpf::dp_double*const data = out.data(size);
// returns:
// { 2.,  4.,  6., 8., 10., 12., 14., 16., 18.}

//use default config value
config.set("work_by_index", false);
op1 = ansys::dpf::Operator("add", config);
op1.connect(0,field1);
op1.connect(1,field2); 
out = op1.getOutputField(0);
ansys::dpf::dp_double*const data2 = out.data(size);
// returns:
// { 1.,  2.,  3., 4.,  5.,  6., 8., 10., 12., 4.,  5.,  6., 7.,  8.,  9.}

// changing the "permissive" config could allow to add fields of different homogeneities
// changing the "binary_operation" config could allow to keep only the intersection between fields ids and not the union
//...

Example of workflows and their scripts

Total deformation

This elementary workflow allows the user to simply read a displacement vector from an analysis and compute its norm.

Python script
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

my_data_sources = dpf.DataSources(my_file_path)
u_op = ops.result.displacement() 
u_op.inputs.data_sources.Connect(my_data_sources) 
norm_op = ops.math.norm() 
norm_op.inputs.field.Connect(u_op.outputs.fields_container) 
my_u_norm = norm_op.outputs.field.GetData()
def define_dpf_workflow(analysis):
    import mech_dpf
    import Ans.DataProcessing as dpf
    import Ans.DataProcessing.operators as ops

    dataSource = dpf.DataSources(analysis.ResultFileName)
    u = ops.result.displacement()
    nrm = ops.math.norm_fc()
    u.inputs.data_sources.Connect(dataSource)
    nrm.Connect(u)
    dpf_workflow = dpf.Workflow()
    dpf_workflow.Add(u)
    dpf_workflow.Add(nrm)
    dpf_workflow.SetOutputContour(nrm)
    dpf_workflow.Record('wf_id', True)
    this.WorkflowId = dpf_workflow.GetRecordedId()
from ansys.dpf import core as dpf
from ansys.dpf.core import operators as ops

my_data_sources = dpf.DataSources(my_path)
my_model = dpf.Model(my_data_sources)

u_op = my_model.results.displacement()
norm_op = ops.math.norm_fc()  
norm_op.inputs.connect(u_op.outputs)
my_u_norm = norm_op.outputs.fields_container()
#include "dpf_api.h"
#include "dpf_api_i.cpp"

//please set the result file path to the right path
ansys::dpf::DataSources my_data_sources;
my_data_sources.addResultFile(my_path.string());

ansys::dpf::Operator u_op("U");
u_op.connect(ansys::dpf::eDataSourcesPin, my_data_sources);

ansys::dpf::Operator norm_op("norm_fc");
norm_op.connect(u_op);

ansys::dpf::FieldsContainer my_u_norm = norm_op.getOutputFieldsContainer(0);

Min max over time of Von Mises stress

This workflow allows the user to read the stress tensors for a range of time steps from an analysis, to implicitly average those elemental nodal tensors to a nodal location, to compute its Von Mises equivalent and finally, to compute the minimum and the maximum over time for each component of the nodal equivalent tensors. This workflow is an example of use of the time scoping pin. This pin expects a scoping in input and allows the user to choose the time or frequency sets of his results.

Python script
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

my_data_sources = dpf.DataSources(my_file_path)
s_eqv_op = ops.result.stress_von_mises() 
s_eqv_op.inputs.data_sources.Connect(my_data_sources) 
s_eqv_op.inputs.time_scoping.Connect(my_time_scoping) 
min_max_op = ops.min_max.min_max_fc() 
min_max_op.inputs.fields_container.Connect(s_eqv_op.outputs.fields_container) 
my_min = min_max_op.outputs.field_min.GetData() 
my_max = min_max_op.outputs.field_max.GetData()
def define_dpf_workflow(analysis):
    import mech_dpf 
    import Ans.DataProcessing as dpf 
    import Ans.DataProcessing.operators as ops
    
    my_data_sources = dpf.DataSources(analysis.ResultFileName)
    s_eqv_op= ops.result.stress_von_mises() 
    s_eqv_op.inputs.data_sources.Connect(my_data_sources) 
    s_eqv_op.inputs.time_scoping.Connect([1]) # the first set 
    dpf_workflow = dpf.Workflow() 
    dpf_workflow.Add(s_eqv_op) 
    dpf_workflow.SetOutputContour(s_eqv_op) 
    dpf_workflow.Record('wf_id', True)
    this.WorkflowId = dpf_workflow.GetRecordedId()
from ansys.dpf import core as dpf
from ansys.dpf.core import operators as ops

my_data_sources = dpf.DataSources(my_path)
my_model = dpf.Model(my_data_sources)

s_op = my_model.results.stress()
s_op.inputs.time_scoping.connect([1])
s_op.inputs.requested_location.connect("Nodal")
eqv_op = ops.invariant.von_mises_eqv_fc(s_op)

min_max_op = ops.min_max.min_max_fc(eqv_op) 

my_min = min_max_op.outputs.field_min()
                   
my_max = min_max_op.outputs.field_max()
#include "dpf_api.h"
#include "dpf_api_i.cpp"

//please set the result file path to the right path
ansys::dpf::DataSources my_data_sources;
my_data_sources.addResultFile(my_path.string());

ansys::dpf::Operator stress_op("S");
stress_op.connect(ansys::dpf::eDataSourcesPin, my_data_sources);
stress_op.connect(ansys::dpf::eTimeScopPin, { 1 });
stress_op.connect(ansys::dpf::eLocationPin, ansys::dpf::locations::nodal);

ansys::dpf::Operator eqv_op("eqv_fc");
eqv_op.connect(stress_op);

ansys::dpf::Operator min_max_op("min_max_fc");
min_max_op.connect(eqv_op);

ansys::dpf::Field my_min = min_max_op.getOutputField(0);
ansys::dpf::Field my_max = min_max_op.getOutputField(1);

Strain tensors scoped on named selection

This workflow is an example of use of the mesh scoping in input of a result reader. Here, the user can extract a mesh scoping (a set of spatial entities: node or elements for example) from a named selection created in mechanical or mapdl. This mesh scoping is then used as an input of a strain tensors reader. The output of this workflow is the strain tensors scoped only on the named selection. Two different versions of this workflow is available: the first one extracts the elements of the named selection and returns an elemental nodal field, the second extracts the nodes of the named selection, the strain reader will consequently average the tensors on the node to take into account the nodal mesh scoping in input.

Python script
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

my_data_sources = dpf.DataSources(my_file_path) 
ns_op= ops.scoping.on_named_selection() 
ns_op.inputs.data_sources.Connect(my_data_sources)
ns_op.inputs.requested_location.Connect('Elemental') #first version with elemental scoping 
ns_op.inputs.named_selection_name.Connect(my_named_selection_name)
strain_op = ops.result.elastic_strain() 
strain_op.inputs.data_sources.Connect(my_data_sources) 
strain_op.inputs.mesh_scoping.Connect(ns_op.outputs.mesh_scoping)
my_elemental_nodal_strains = strain_op.outputs.fields_container.GetData() 

ns_op.inputs.requested_location.Connect('Nodal') #second version with nodal scoping 
my_nodal_strains = strain_op.outputs.fields_container.GetData() 

def define_dpf_workflow(analysis):
    import mech_dpf
    import Ans.DataProcessing as dpf
    import Ans.DataProcessing.operators as ops

    dataSource = dpf.DataSources(analysis.ResultFileName)
    ns_op= ops.scoping.on_named_selection()   
    ns_op.inputs.data_sources.Connect(dataSource)  
    ns_op.inputs.requested_location.Connect('Elemental') #first version with elemental scoping   
    ns_op.inputs.named_selection_name.Connect("SELECTION")  
    strain_op = ops.result.elastic_strain_X()  
    strain_op.inputs.data_sources.Connect(dataSource)  
    strain_op.inputs.mesh_scoping.Connect(ns_op.outputs.mesh_scoping)  
    to_elemental_op = ops.averaging.to_elemental_fc() #make an elemental average on the elemental nodal field 
    to_elemental_op.Connect(strain_op)  
    dpf_workflow = dpf.Workflow() 
    dpf_workflow.Add(strain_op) 
    dpf_workflow.Add(to_elemental_op) 
    dpf_workflow.SetOutputContour(to_elemental_op) 
    dpf_workflow.Record('wf_id', True)
    this.WorkflowId = dpf_workflow.GetRecordedId()
from ansys.dpf import core as dpf
from ansys.dpf.core import operators as ops

my_data_sources = dpf.DataSources(my_path)
my_model = dpf.Model(my_data_sources)

strain_op = my_model.results.strain()

ns_op = ops.scoping.on_named_selection() 
ns_op.inputs.requested_location.connect("Elemental") #first version with elemental scoping 
ns_op.inputs.named_selection_name.connect(my_named_selection_name)

strain_op.inputs.connect(ns_op.outputs)
my_elemental_nodal_strains = strain_op.outputs.fields_container()

ns_op.inputs.requested_location.connect("Nodal") #second version with nodal scoping 
my_nodal_strains = strain_op.outputs.fields_container()
#include "dpf_api.h"
#include "dpf_api_i.cpp"

//please set the result file path to the right path
ansys::dpf::DataSources my_data_sources;
my_data_sources.addResultFile(my_path.string());

ansys::dpf::Operator strain_op("EPEL");
strain_op.connect(ansys::dpf::eDataSourcesPin, my_data_sources);
strain_op.connect(ansys::dpf::eLocationPin, ansys::dpf::locations::nodal);

ansys::dpf::Operator ns_op("scoping_provider_by_ns");
ns_op.connect(ansys::dpf::eDataSourcesPin, my_data_sources);
ns_op.connect(0, ansys::dpf::locations::elemental);
ns_op.connect(1, my_named_selection_name);

strain_op.connect(ansys::dpf::eMeshScopPin, ns_op, 0);

ansys::dpf::FieldsContainer my_nodal_strains = strain_op.getOutputFieldsContainer(0);

Stress tensors scoped on one element type

This workflow is another example of use of the mesh scoping in input of a result reader. Here, the user requests a mesh scoping including all the elements of mapdl element type 186. This mesh scoping is then used as an input of a stress tensors reader. The output of this workflow is the stress tensors on all the elements of element type 186.

Python script
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

my_data_sources = dpf.DataSources(my_file_path) 
scop_extract_op = ops.scoping.on_property()
scop_extract_op.inputs.data_sources.Connect(my_data_sources)
scop_extract_op.inputs.requested_location.Connect('Elemental') # elemental scoping 
scop_extract_op.inputs.property_name.Connect('mapdl_element_type')
scop_extract_op.inputs.property_id.Connect(186)
stress_op = ops.result.stress() 
stress_op.inputs.data_sources.Connect(my_data_sources) 
stress_op.inputs.mesh_scoping.Connect(scop_extract_op.outputs.mesh_scoping)
my_elemental_nodal_stress = stress_op.outputs.fields_container.GetData() 
def define_dpf_workflow(analysis):
    import mech_dpf
    import Ans.DataProcessing as dpf
    import Ans.DataProcessing.operators as ops

    dataSource = dpf.DataSources(analysis.ResultFileName)
    scop_extract_op = ops.scoping.on_property() 
    scop_extract_op.inputs.data_sources.Connect(dataSource) 
    scop_extract_op.inputs.requested_location.Connect('Elemental') 
    scop_extract_op.inputs.property_name.Connect('mapdl_element_type') 
    scop_extract_op.inputs.property_id.Connect(186)  
    stress_op = ops.result.stress()  
    stress_op.inputs.data_sources.Connect(dataSource)  
    stress_op.inputs.mesh_scoping.Connect(scop_extract_op.outputs.mesh_scoping)  
    dpf_workflow = dpf.Workflow() 
    dpf_workflow.Add(scop_extract_op) 
    dpf_workflow.Add(stress_op) 
    dpf_workflow.SetOutputContour(stress_op) 
    dpf_workflow.Record('wf_id', True)
    this.WorkflowId = dpf_workflow.GetRecordedId()
from ansys.dpf import core as dpf
from ansys.dpf.core import operators as ops

my_data_sources = dpf.DataSources(my_path)
my_model = dpf.Model(my_data_sources)

stress_op = my_model.results.stress()

scop_extract_op = ops.scoping.on_property()
scop_extract_op.inputs.data_sources.connect(my_data_sources)
scop_extract_op.inputs.requested_location.connect('Elemental') # elemental scoping 
scop_extract_op.inputs.property_name.connect('mapdl_element_type')
scop_extract_op.inputs.property_id.connect(186)

stress_op.inputs.mesh_scoping.connect(scop_extract_op.outputs)
my_elemental_nodal_stress = stress_op.outputs.fields_container() 
#include "dpf_api.h"
#include "dpf_api_i.cpp"

//please set the result file path to the right path
ansys::dpf::DataSources my_data_sources;
my_data_sources.addResultFile(my_path.string());

ansys::dpf::Operator stress_op("S");
stress_op.connect(ansys::dpf::eDataSourcesPin, my_data_sources);

ansys::dpf::Operator scop_extract_op("scoping_provider_by_prop");
scop_extract_op.connect(ansys::dpf::eDataSourcesPin, my_data_sources);
scop_extract_op.connect(0, ansys::dpf::locations::elemental);
scop_extract_op.connect(1, std::string("mapdl_element_type"));
scop_extract_op.connect(2, 186);

stress_op.connect(ansys::dpf::eMeshScopPin, scop_extract_op, 0);

ansys::dpf::FieldsContainer my_elemental_nodal_stress = stress_op.getOutputFieldsContainer(0);

High pass filtering on elemental stress

This advanced workflow computes the normal ZZ stress averaged on elements and apply a high pass filter keeping all the stress values higher than 0.5*maximum stress.

Python script
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

my_data_source = dpf.DataSources() 

#please set the result file path to the right path
my_data_source.SetResultFilePath(my_path)

s = ops.result.stress()
s.inputs.data_sources.Connect(my_data_source)

to_elemental = ops.averaging.to_elemental_fc()
to_elemental.inputs.fields_container.Connect(s.outputs.fields_container)

comp =ops.logic.component_selector_fc()	
comp.inputs.component_number.Connect(2)
comp.inputs.fields_container.Connect(to_elemental.outputs.fields_container)

min_max = ops.min_max.min_max_over_label_fc()
min_max.inputs.fields_container.Connect(comp.outputs.fields_container)
min_max.inputs.label.Connect("time")

scale = ops.math.scale(min_max.outputs.field_max, 0.5)
high_pass = ops.filter.field_high_pass_fc(comp, scale)

fields = high_pass.outputs.fields_container.GetData()
def define_dpf_workflow(analysis):
    import mech_dpf
    import Ans.DataProcessing as dpf
    import Ans.DataProcessing.operators as ops

    dataSource = dpf.DataSources(analysis.ResultFileName)
    s = ops.result.stress()
    s.inputs.data_sources.Connect(dataSource)
    
    to_elemental = ops.averaging.to_elemental_fc()
    to_elemental.inputs.fields_container.Connect(s.outputs.fields_container)
    
    comp =ops.logic.component_selector_fc()	
    comp.inputs.component_number.Connect(2)
    comp.inputs.fields_container.Connect(to_elemental.outputs.fields_container)
    
    min_max = ops.min_max.min_max_over_label_fc()
    min_max.inputs.fields_container.Connect(comp.outputs.fields_container)
    min_max.inputs.label.Connect("time")
    
    scale = ops.math.scale(min_max.outputs.field_max, 0.5)
    high_pass = ops.filter.field_high_pass_fc(comp, scale)
    u = ops.result.displacement()
    u.inputs.data_sources.Connect(dataSource)

    dpf_workflow = dpf.Workflow() 
    dpf_workflow.Add(s) 
    dpf_workflow.Add(to_elemental) 
    dpf_workflow.Add(min_max) 
    dpf_workflow.SetOutputContour(high_pass) 
    dpf_workflow.SetOutputWarpField(u) 
    dpf_workflow.Record('wf_id', True)
    this.WorkflowId = dpf_workflow.GetRecordedId()
from ansys.dpf import core as dpf
from ansys.dpf.core import operators as ops

#please set the result file path to the right path
my_data_source = dpf.DataSources(my_path) 
my_model = dpf.Model(my_data_source)

s = my_model.results.stress()

to_elemental = ops.averaging.to_elemental_fc()
to_elemental.inputs.connect(s.outputs)

comp = ops.logic.component_selector_fc()
comp.inputs.component_number.connect(2)
comp.inputs.connect(to_elemental.outputs)

min_max = ops.min_max.min_max_over_label_fc()
min_max.inputs.connect(comp.outputs)
min_max.inputs.label.connect("time")

scale = ops.math.scale(min_max.outputs.field_max, 0.5)

high_pass = ops.filter.field_high_pass_fc(comp,scale)

fields = high_pass.outputs.fields_container()
#include "dpf_api.h"
#include "dpf_api_i.cpp"

//please set the result file path to the right path
ansys::dpf::DataSources my_data_sources;
my_data_sources.addResultFile(my_path.string());

ansys::dpf::Operator s("S");
s.connect(ansys::dpf::eDataSourcesPin, my_data_sources);

ansys::dpf::Operator to_elemental("entity_average_fc");
to_elemental.connect(s);

ansys::dpf::Operator comp("component_selector_fc");
comp.connect(to_elemental);
comp.connect(1, 2); //ZZ comp of stress

ansys::dpf::Operator min_max("min_max_over_label_fc");
min_max.connect(comp);
min_max.connect(1, ansys::dpf::labels::time);

ansys::dpf::Operator scale("scale");
scale.connect(min_max);
scale.connect(1, 0.5);

ansys::dpf::Operator high_pass("core::field::high_pass_fc");
high_pass.connect(comp);
high_pass.connect(1, scale, 0);

ansys::dpf::FieldsContainer fields = high_pass.getOutputFieldsContainer(0);

Stress calculation on a multibody simulation without averaging across bodies

This workflow shows the computation of stresses in a multibody simulation without doing averaging across the different bodies.

Python script
import mech_dpf
import Ans.DataProcessing as dpf
import Ans.DataProcessing.operators as ops

my_data_sources = dpf.DataSources(my_file_path)
    
tfreq_op = ops.metadata.time_freq_provider()
tfreq_op.inputs.data_sources.Connect(my_data_sources)
tfreq_support = tfreq_op.outputs.time_freq_support.GetData()
tfreq = tfreq_support.TimeFreqs
    
mesh_op = ops.mesh.mesh_provider()
mesh_op.inputs.data_sources.Connect(my_data_sources)
    
spm_op = ops.scoping.split_on_property_type(label1="mat")
spm_op.inputs.mesh.Connect(mesh_op)
    
stress_op = ops.result.stress_Z()
stress_op.inputs.data_sources.Connect(my_data_sources)
stress_op.inputs.requested_location.Connect('Nodal')
stress_op.inputs.time_scoping.Connect(tfreq)
stress_op.inputs.mesh_scoping.Connect(spm_op)

my_stresses = stress_op.outputs.fields_container.GetData()
def define_dpf_workflow(analysis):
    import mech_dpf
    import Ans.DataProcessing as dpf
    import Ans.DataProcessing.operators as ops
    
    dataSource = dpf.DataSources(analysis.ResultFileName)
        
    tfreq_op = ops.metadata.time_freq_provider()
    tfreq_op.inputs.data_sources.Connect(dataSource)
    tfreq_support = tfreq_op.outputs.time_freq_support.GetData()
    tfreq = tfreq_support.TimeFreqs
        
    mesh_op = ops.mesh.mesh_provider()
    mesh_op.inputs.data_sources.Connect(dataSource)
        
    spm_op = ops.scoping.split_on_property_type(label1="mat")
    spm_op.inputs.mesh.Connect(mesh_op)
        
    stress_op = ops.result.stress_Z()
    stress_op.inputs.data_sources.Connect(dataSource)
    stress_op.inputs.requested_location.Connect('Nodal')
    stress_op.inputs.time_scoping.Connect(tfreq)
    stress_op.inputs.mesh_scoping.Connect(spm_op)

    meshes_op = ops.mesh.split_mesh(property='mat')
    meshes_op.inputs.mesh.Connect(mesh_op)

    dpf_workflow = dpf.Workflow()
    dpf_workflow.Add(tfreq_op)
    dpf_workflow.Add(mesh_op)
    dpf_workflow.Add(spm_op)
    dpf_workflow.Add(stress_op)
    dpf_workflow.Add(meshes_op)
    dpf_workflow.SetOutputContour(stress_op)
    dpf_workflow.SetOutputMesh(meshes_op)
    dpf_workflow.Record('wf_id', False)
    this.WorkflowId = dpf_workflow.GetRecordedId()
from ansys.dpf import core as dpf
from ansys.dpf.core import operators as ops

#please set the result file path to the right path
my_data_sources = dpf.DataSources(my_file_path)
my_model = dpf.Model(my_data_sources)

mesh = my_model.metadata.meshed_region

tfreq_support = my_model.metadata.time_freq_support
tfreq = tfreq_support.time_frequencies

spm_op = dpf.operators.scoping.split_on_property_type(mesh=mesh, label1="mat")
    
stress_op = dpf.operators.result.stress_Z()
stress_op.inputs.data_sources.connect(my_data_sources)
stress_op.inputs.requested_location.connect('Nodal')
stress_op.inputs.time_scoping.connect(tfreq)
stress_op.inputs.mesh_scoping.connect(spm_op)

my_stresses = stress_op.outputs.fields_container()
#include "dpf_api.h"
#include "dpf_api_i.cpp"

boost::filesystem::path my_path = unit_test_helper::unitTestPath() / "rst_operators" / "piston_rod.rst"

//please set the result file path to the right path
ansys::dpf::DataSources my_data_sources;
my_data_sources.addResultFile(my_path.string());

ansys::dpf::Operator tfreq_op("time_freq_support_provider");
tfreq_op.connect(4, my_data_sources);
ansys::dpf::TimeFreqSupport tfreq_support = tfreq_op.getOutput<ansys::dpf::TimeFreqSupport>(0);
ansys::dpf::Field tfreq = tfreq_support.frequencies();

ansys::dpf::Operator mesh_op("mesh_provider");
mesh_op.connect(4, my_data_sources);
ansys::dpf::MeshedRegion mesh = mesh_op.getOutput<ansys::dpf::MeshedRegion>(0);

ansys::dpf::Operator spm_op("scoping::by_property");
spm_op.connect(7, mesh);
spm_op.connect(13, std::string("mat"));
ansys::dpf::ScopingsContainer mesh_scoping = spm_op.getOutput<ansys::dpf::ScopingsContainer>(0);

ansys::dpf::Operator stress_op("SZ");
stress_op.connect(0, tfreq);
stress_op.connect(1, mesh_scoping);
stress_op.connect(4, my_data_sources);
stress_op.connect(9, ansys::dpf::locations::nodal);

ansys::dpf::FieldsContainer my_stresses = stress_op.getOutputFieldsContainer(0);

math: imaginary part

Description

Extracts element-wise imaginary part of field containers containing complex fields.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: img_part
  • full name: math.img_part
  • internal name: img_part
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.img_part() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.img_part() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("img_part"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: amplitude (fields container)

Description

Computes the amplitude of a real and an imaginary field.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: amplitude_fc
  • full name: math.amplitude_fc
  • internal name: amplitude_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.amplitude_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.amplitude_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("amplitude_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

metadata: mesh support provider

Description

Reads the mesh support.

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

Streams (result file container) (optional).

pin 4requested
data_sourcesname
(data_sources)expected type(s)

If the stream is null, retrieves the file path from the data sources.

Outputs

pin 0requested
abstract_field_supportname
(abstract_field_support)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: mesh_support_provider
  • full name: metadata.mesh_support_provider
  • internal name: mesh_support_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.mesh_support_provider() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_abstract_field_support = op.outputs.abstract_field_support.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.mesh_support_provider() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_abstract_field_support = op.outputs.abstract_field_support()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh_support_provider"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::AbstractFieldSupport my_abstract_field_support = op.getOutput<ansys::dpf::AbstractFieldSupport>(0);

result: creep strain principal 1

Description

Read/compute element nodal component creep strains 1st principal component by calling the readers defined by the datasources and computing its eigen values. The off-diagonal strains are first converted from Voigt notation to the standard strain values.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain_principal_1
  • full name: result.creep_strain_principal_1
  • internal name: EPCR1
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain_principal_1() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain_principal_1() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPCR1"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: beam axial stress (LSDyna)

Description

Read Beam Axial Stress (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
integration_pointname
(int32)expected type(s)

integration point where the result will be read from. Default value: 0 (first integration point).

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: beam_axial_stress
  • full name: result.beam_axial_stress
  • internal name: B_SN
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.beam_axial_stress() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.integration_point.Connect(my_integration_point)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.beam_axial_stress() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.integration_point.connect(my_integration_point)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("B_SN"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_integration_point);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: unit convert (fields container)

Description

Converts an input fields container of a given unit to another unit.

Inputs

pin 0requested
fields_container (modified inplace)name
(fields_container)expected type(s)
pin 1requested
unit_namename
(string)expected type(s)

unit as a string, ex 'm' for meter, 'Pa' for pascal,...

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.

Scripting

  • category: math
  • plugin: core
  • scripting name: unit_convert_fc
  • full name: math.unit_convert_fc
  • internal name: unit_convert_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.unit_convert_fc() # operator instantiation
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.unit_name.Connect(my_unit_name)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.unit_convert_fc() # operator instantiation
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.unit_name.connect(my_unit_name)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("unit_convert_fc"); // operator instantiation
op.connect(0, my_fields_container (modified inplace));
op.connect(1, my_unit_name);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: property field get attribute

Description

A PropertyField in pin 0 and a property name (string) in pin 1 are expected in input.

Inputs

pin 0requested
property_fieldname
(property_field)expected type(s)
pin 1requested
property_namename
(string)expected type(s)

Accepted inputs are: 'time_freq_support', 'scoping' and 'header'.

Outputs

pin 0requested
propertyname
(time_freq_support | scoping | abstract_data_tree)expected type(s)

Property value.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: propertyfield_get_attribute
  • full name: utility.propertyfield_get_attribute
  • internal name: propertyfield::get_attribute
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.propertyfield_get_attribute() # operator instantiation
op.inputs.property_field.Connect(my_property_field)
op.inputs.property_name.Connect(my_property_name)
my_property = op.outputs.property.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.propertyfield_get_attribute() # operator instantiation
op.inputs.property_field.connect(my_property_field)
op.inputs.property_name.connect(my_property_name)
my_property = op.outputs.property()
#include "dpf_api.h"

ansys::dpf::Operator op("propertyfield::get_attribute"); // operator instantiation
op.connect(0, my_property_field);
op.connect(1, my_property_name);
ansys::dpf::TimeFreqSupport my_property = op.getOutput<ansys::dpf::TimeFreqSupport>(0);

result: element orientations X

Description

Read/compute element euler angles 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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: element_orientations_X
  • full name: result.element_orientations_X
  • internal name: EULX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.element_orientations_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.element_orientations_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EULX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: norm (fields container)

Description

Computes the element-wise L2 norm of the field elementary data. This process is applied on each field of the input fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
scalar_intname
(int32)expected type(s)

Lp normalisation type, p = 1, 2, ...n - Default Lp=2

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: math
  • plugin: core
  • scripting name: norm_fc
  • full name: math.norm_fc
  • internal name: norm_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.norm_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.scalar_int.Connect(my_scalar_int)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.norm_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.scalar_int.connect(my_scalar_int)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("norm_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_scalar_int);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

mapping: prepare mapping workflow

Description

Generates a workflow that can map results from a support to another one.

Inputs

pin 0requested
input_supportname
(field | abstract_meshed_region)expected type(s)
pin 1requested
output_supportname
(field | abstract_meshed_region)expected type(s)
pin 2requested
filter_radiusname
(double)expected type(s)

Radius size for the RBF filter

pin 3optional
influence_boxname
(double)expected type(s)

Outputs

pin 0requested
mapping_workflowname
(workflow)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mapping
  • plugin: core
  • scripting name: prepare_mapping_workflow
  • full name: mapping.prepare_mapping_workflow
  • internal name: prepare_mapping_workflow
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mapping.prepare_mapping_workflow() # operator instantiation
op.inputs.input_support.Connect(my_input_support)
op.inputs.output_support.Connect(my_output_support)
op.inputs.filter_radius.Connect(my_filter_radius)
op.inputs.influence_box.Connect(my_influence_box)
my_mapping_workflow = op.outputs.mapping_workflow.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mapping.prepare_mapping_workflow() # operator instantiation
op.inputs.input_support.connect(my_input_support)
op.inputs.output_support.connect(my_output_support)
op.inputs.filter_radius.connect(my_filter_radius)
op.inputs.influence_box.connect(my_influence_box)
my_mapping_workflow = op.outputs.mapping_workflow()
#include "dpf_api.h"

ansys::dpf::Operator op("prepare_mapping_workflow"); // operator instantiation
op.connect(0, my_input_support);
op.connect(1, my_output_support);
op.connect(2, my_filter_radius);
op.connect(3, my_influence_box);
ansys::dpf::Workflow my_mapping_workflow = op.getOutput<ansys::dpf::Workflow>(0);

math: sqrt (fields container)

Description

Computes element-wise sqrt(field1).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: sqrt_fc
  • full name: math.sqrt_fc
  • internal name: sqrt_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.sqrt_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.sqrt_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("sqrt_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: conjugate

Description

Computes element-wise conjugate of field containers containing complex fields.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: conjugate
  • full name: math.conjugate
  • internal name: conjugate
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.conjugate() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.conjugate() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("conjugate"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: html doc

Description

Create dpf's html documentation. Only on Windows.

Inputs

pin 0optional
output_pathname
(string)expected type(s)

default is {working directory}/dataProcessingDoc.html

pin 1optional
exposure_levelname
(int32)expected type(s)

Generate the documentation depending on exposure level : 0 (default) for public operators, 1 includes hidden operator, 2 includes private operator, 3 includes operator without specifications.

Outputs

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: documentation
  • scripting name: html_doc
  • full name: utility.html_doc
  • internal name: html_doc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.html_doc() # operator instantiation
op.inputs.output_path.Connect(my_output_path)
op.inputs.exposure_level.Connect(my_exposure_level)
from ansys.dpf import core as dpf 

op = dpf.operators.utility.html_doc() # operator instantiation
op.inputs.output_path.connect(my_output_path)
op.inputs.exposure_level.connect(my_exposure_level)
#include "dpf_api.h"

ansys::dpf::Operator op("html_doc"); // operator instantiation
op.connect(0, my_output_path);
op.connect(1, my_exposure_level);

math: real part

Description

Extracts element-wise real part of field containers containing complex fields.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: real_part
  • full name: math.real_part
  • internal name: realP_part
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.real_part() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.real_part() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("realP_part"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: current density

Description

Read/compute Current Density by calling the readers defined by the datasources.

Warning: There are multiple results named "current density".

This operator returns the elemental "Source current density", also named "JS" in MAPDL and Mechanical.

To retrieve the result named "current density" in Mechanical or "JC" in MAPDL, use the solver specific operator: mapdl::rth::JC.

Supported file types

  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: current_density
  • full name: result.current_density
  • internal name: ECD
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.current_density() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.current_density() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ECD"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

logic: same property fields container?

Description

Checks if two property_fields_container are identical.

Inputs

pin 0requested
property_fields_containerAname
(property_fields_container)expected type(s)
pin 1requested
property_fields_containerBname
(property_fields_container)expected type(s)

Outputs

pin 0requested
booleanname
(bool)expected type(s)

bool (true if identical...)

pin 1requested
messagename
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: identical_pfc
  • full name: logic.identical_pfc
  • internal name: compare::property_fields_container
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.identical_pfc() # operator instantiation
op.inputs.property_fields_containerA.Connect(my_property_fields_containerA)
op.inputs.property_fields_containerB.Connect(my_property_fields_containerB)
my_boolean = op.outputs.boolean.GetData()
my_message = op.outputs.message.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.identical_pfc() # operator instantiation
op.inputs.property_fields_containerA.connect(my_property_fields_containerA)
op.inputs.property_fields_containerB.connect(my_property_fields_containerB)
my_boolean = op.outputs.boolean()
my_message = op.outputs.message()
#include "dpf_api.h"

ansys::dpf::Operator op("compare::property_fields_container"); // operator instantiation
op.connect(0, my_property_fields_containerA);
op.connect(1, my_property_fields_containerB);
bool my_boolean = op.getOutput<bool>(0);
std::string my_message = op.getOutput<std::string>(1);

math: multiply (complex fields)

Description

Computes multiplication between two field containers containing complex fields.

Inputs

pin 0requested
fields_containerAname
(fields_container)expected type(s)
pin 1requested
fields_containerBname
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: cplx_multiply
  • full name: math.cplx_multiply
  • internal name: cplx_multiply
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.cplx_multiply() # operator instantiation
op.inputs.fields_containerA.Connect(my_fields_containerA)
op.inputs.fields_containerB.Connect(my_fields_containerB)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.cplx_multiply() # operator instantiation
op.inputs.fields_containerA.connect(my_fields_containerA)
op.inputs.fields_containerB.connect(my_fields_containerB)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("cplx_multiply"); // operator instantiation
op.connect(0, my_fields_containerA);
op.connect(1, my_fields_containerB);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: merge result infos

Description

Assembles a set of result information into a unique one.

Inputs

pin 0, 1...requested, ellipsis
result_infosname
(vector> | result_info)expected type(s)

A vector of result info containers to merge or result infos from pin 0 to ...

Outputs

pin 0requested
merged_result_infosname
(result_info)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
read_inputs_in_parallelIf this option is set to true, the operator's inputs will be evaluated in parallel.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the operator's inputs will be evaluated in parallel.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_result_infos
  • full name: utility.merge_result_infos
  • internal name: merge::result_info
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_result_infos() # operator instantiation
op.inputs.result_infos1.Connect(my_result_infos_1)
op.inputs.result_infos2.Connect(my_result_infos_2)
my_merged_result_infos = op.outputs.merged_result_infos.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_result_infos() # operator instantiation
op.inputs.result_infos1.connect(my_result_infos_1)
op.inputs.result_infos2.connect(my_result_infos_2)
my_merged_result_infos = op.outputs.merged_result_infos()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::result_info"); // operator instantiation
op.connect(0, my_result_infos_1);
op.connect(1, my_result_infos_2);
ansys::dpf::ResultInfo my_merged_result_infos = op.getOutput<ansys::dpf::ResultInfo>(0);

result: global total mass (LSDyna)

Description

Read Global Total Mass (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_total_mass
  • full name: result.global_total_mass
  • internal name: GLOB_TM
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_total_mass() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_total_mass() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_TM"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: unit convert

Description

Converts an input field/fields container or mesh of a given unit to another unit.

Inputs

pin 0requested
entity_to_convert (modified inplace)name
(field | fields_container | abstract_meshed_region | meshes_container)expected type(s)
pin 1requested
unit_namename
(string | int32 | field)expected type(s)

unit as a string, ex 'm' for meter, 'Pa' for pascal,... Or ansys unit system's ID, or a field from which expected unit will be extracted.

Outputs

pin 0requested
converted_entityname
(field | fields_container | abstract_meshed_region | meshes_container)expected type(s)

the output entity is the same as the input (inplace operator)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.

Scripting

  • category: math
  • plugin: core
  • scripting name: unit_convert
  • full name: math.unit_convert
  • internal name: unit_convert
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.unit_convert() # operator instantiation
op.inputs.entity_to_convert (modified inplace).Connect(my_entity_to_convert (modified inplace))
op.inputs.unit_name.Connect(my_unit_name)
my_converted_entity = op.outputs.converted_entity.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.unit_convert() # operator instantiation
op.inputs.entity_to_convert (modified inplace).connect(my_entity_to_convert (modified inplace))
op.inputs.unit_name.connect(my_unit_name)
my_converted_entity = op.outputs.converted_entity()
#include "dpf_api.h"

ansys::dpf::Operator op("unit_convert"); // operator instantiation
op.connect(0, my_entity_to_convert (modified inplace));
op.connect(1, my_unit_name);
ansys::dpf::Field my_converted_entity = op.getOutput<ansys::dpf::Field>(0);

math: norm (field)

Description

Computes the element-wise Lp norm of the field elementary data. Default Lp=L2

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
scalar_intname
(int32)expected type(s)

Lp normalisation type, p = 1, 2, ...n - Default Lp=L2

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: norm
  • full name: math.norm
  • internal name: norm
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.norm() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.scalar_int.Connect(my_scalar_int)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.norm() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.scalar_int.connect(my_scalar_int)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("norm"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_scalar_int);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: make label space

Description

Assemble strings and integers to make a label space.

Inputs

pin 0optional
base_labelname
(label_space | fields_container | scopings_container)expected type(s)

Used as a base label (extracted from Fields/Scoping Container, or directly from Label Space) that is concatenated with provided values.

pin 1requested
label_namename
(string)expected type(s)
pin 2, 3...requested, ellipsis
label_valuename
(int32)expected type(s)

Outputs

pin 0requested
labelname
(label_space)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: make_label_space
  • full name: utility.make_label_space
  • internal name: make_label_space
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.make_label_space() # operator instantiation
op.inputs.base_label.Connect(my_base_label)
op.inputs.label_name.Connect(my_label_name)
op.inputs.label_value1.Connect(my_label_value_1)
op.inputs.label_value2.Connect(my_label_value_2)
my_label = op.outputs.label.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.make_label_space() # operator instantiation
op.inputs.base_label.connect(my_base_label)
op.inputs.label_name.connect(my_label_name)
op.inputs.label_value1.connect(my_label_value_1)
op.inputs.label_value2.connect(my_label_value_2)
my_label = op.outputs.label()
#include "dpf_api.h"

ansys::dpf::Operator op("make_label_space"); // operator instantiation
op.connect(0, my_base_label);
op.connect(1, my_label_name);
op.connect(2, my_label_value_1);
op.connect(3, my_label_value_2);
ansys::dpf::LabelSpace my_label = op.getOutput<ansys::dpf::LabelSpace>(0);

math: sqrt (field)

Description

Computes element-wise sqrt(field1).

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: sqrt
  • full name: math.sqrt
  • internal name: sqrt
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.sqrt() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.sqrt() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("sqrt"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: accumulate min over label

Description

Compute the component-wise sum over all the fields that have the same ID as the label set as input in the fields container and take its opposite. This computation can be incremental. If the input fields container is connected and the operator is run multiple times, the output field will be on all the connected inputs.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
labelname
(string)expected type(s)

Label of the fields container where it should operate.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

incrementalThis operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
(bool)expected type(s)
truedefault value
: This operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: accumulate_min_over_label_fc
  • full name: math.accumulate_min_over_label_fc
  • internal name: accumulate_min_over_label_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.accumulate_min_over_label_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.label.Connect(my_label)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.accumulate_min_over_label_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.label.connect(my_label)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("accumulate_min_over_label_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_label);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: y plus (y+)

Description

Read Y Plus (y+) by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: y_plus
  • full name: result.y_plus
  • internal name: YPLUS
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.y_plus() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.y_plus() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("YPLUS"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: +

Description

Computes the sum of two fields. If one field's scoping has 'overall' location, then these field's values are applied on the entire other field. If one of the input field is empty, the remaining is forwarded to the output. When using a constant or 'work_by_index', it's possible to use 'inplace' to reuse one of the fields.

Inputs

pin 0requested
fieldAname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

pin 1requested
fieldBname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
inplaceThe output is written over the input to save memory if this config is set to true.
(bool)expected type(s)
falsedefault value
: The output is written over the input to save memory if this config is set to true.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: add
  • full name: math.add
  • internal name: add
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.add() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.add() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("add"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

server: grpc shutdown server

Description

Shutdowns dpf's grpc server

Inputs

pin 0requested
grpc_streamname
(streams_container)expected type(s)

dpf streams handling the server

Outputs

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: server
  • plugin: grpc
  • scripting name: grpc_shutdown_server
  • full name: server.grpc_shutdown_server
  • internal name: grpc_server_shutdown
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.server.grpc_shutdown_server() # operator instantiation
op.inputs.grpc_stream.Connect(my_grpc_stream)
from ansys.dpf import core as dpf 

op = dpf.operators.server.grpc_shutdown_server() # operator instantiation
op.inputs.grpc_stream.connect(my_grpc_stream)
#include "dpf_api.h"

ansys::dpf::Operator op("grpc_server_shutdown"); // operator instantiation
op.connect(0, my_grpc_stream);

result: magnetic scalar potential

Description

Read/compute Magnetic Scalar Potential by calling the readers defined by the datasources.

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: magnetic_scalar_potential
  • full name: result.magnetic_scalar_potential
  • internal name: MAG
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.magnetic_scalar_potential() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.magnetic_scalar_potential() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MAG"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: time freq interpolation

Description

Interpolates between all the matching fields of a fields container at given times or frequencies, using ramped: fieldOut = field1*(1.-fact)+field2*(fact), or stepped: fieldOut=field2. If the time freq is higher than the max available, the field at the max time freq is taken. Computes the output time freq support to support the fields container

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
time_freq_valuesname
(double | vector | field)expected type(s)

list of frequencies or times needed. To specify load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps".

pin 2optional
stepname
(int32)expected type(s)

if a Field is set as input, the step ids should be its scoping.

pin 3optional
interpolation_typename
(int32)expected type(s)

1 is ramped, 2 is stepped, default is 1.

pin 4optional
force_new_time_freq_supportname
(bool)expected type(s)

If set to true, the output fields container will always have a new time freq support rescoped to the output time_freq_values (default is false). If set to false, the time freq support is only recreated when time or frequency values are between existing ones.

pin 8optional
time_freq_supportname
(time_freq_support)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.

Scripting

  • category: math
  • plugin: core
  • scripting name: time_freq_interpolation
  • full name: math.time_freq_interpolation
  • internal name: time_freq_interpolation
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.time_freq_interpolation() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.time_freq_values.Connect(my_time_freq_values)
op.inputs.step.Connect(my_step)
op.inputs.interpolation_type.Connect(my_interpolation_type)
op.inputs.force_new_time_freq_support.Connect(my_force_new_time_freq_support)
op.inputs.time_freq_support.Connect(my_time_freq_support)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.time_freq_interpolation() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.time_freq_values.connect(my_time_freq_values)
op.inputs.step.connect(my_step)
op.inputs.interpolation_type.connect(my_interpolation_type)
op.inputs.force_new_time_freq_support.connect(my_force_new_time_freq_support)
op.inputs.time_freq_support.connect(my_time_freq_support)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("time_freq_interpolation"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_time_freq_values);
op.connect(2, my_step);
op.connect(3, my_interpolation_type);
op.connect(4, my_force_new_time_freq_support);
op.connect(8, my_time_freq_support);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: + (fields container)

Description

Selects all fields with the same label space in the input fields container and add those together. If fields, doubles, or vectors of doubles, are put in input they are added to all the fields.

Inputs

pin 0, 1...requested, ellipsis
fields_containername
(fields_container | field | double | vector)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: add_fc
  • full name: math.add_fc
  • internal name: add_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.add_fc() # operator instantiation
op.inputs.fields_container1.Connect(my_fields_container_1)
op.inputs.fields_container2.Connect(my_fields_container_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.add_fc() # operator instantiation
op.inputs.fields_container1.connect(my_fields_container_1)
op.inputs.fields_container2.connect(my_fields_container_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("add_fc"); // operator instantiation
op.connect(0, my_fields_container_1);
op.connect(1, my_fields_container_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: sin (fields container)

Description

Computes element-wise sin(field[i]).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: sin_fc
  • full name: math.sin_fc
  • internal name: sin_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.sin_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.sin_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("sin_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: tangential contact force

Description

Read/compute tangential contact force by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: tangential_contact_force
  • full name: result.tangential_contact_force
  • internal name: CFFTAN
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.tangential_contact_force() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.tangential_contact_force() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("CFFTAN"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: + constant (field)

Description

Computes the sum of a field (in 0) and a scalar (in 1).

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
weightsname
(double | vector)expected type(s)

double or vector of double

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: add_constant
  • full name: math.add_constant
  • internal name: add_constant
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.add_constant() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.weights.Connect(my_weights)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.add_constant() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.weights.connect(my_weights)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("add_constant"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_weights);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: / (component-wise field)

Description

Computes component-wise fraction between two fields of same dimensionality. If one field's scoping has an 'overall' location, then this field's values are applied on the other field entirely. When using a constant or 'work_by_index', you can use 'inplace' to reuse one of the fields.

Inputs

pin 0requested
fieldAname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
fieldBname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
inplaceThe output is written over the input to save memory if this config is set to true.
(bool)expected type(s)
falsedefault value
: The output is written over the input to save memory if this config is set to true.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: component_wise_divide
  • full name: math.component_wise_divide
  • internal name: component_wise_divide
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.component_wise_divide() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.component_wise_divide() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("component_wise_divide"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: normal contact force

Description

Read/compute normal contact force by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: normal_contact_force
  • full name: result.normal_contact_force
  • internal name: CFFNOR
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.normal_contact_force() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.normal_contact_force() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("CFFNOR"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: + constant (fields container)

Description

Computes the sum of a field (in 0) and a scalar (in 1).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
weightsname
(double | vector)expected type(s)

double or vector of double

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: add_constant_fc
  • full name: math.add_constant_fc
  • internal name: add_constant_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.add_constant_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.weights.Connect(my_weights)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.add_constant_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.weights.connect(my_weights)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("add_constant_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_weights);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

invariant: scalar invariants (fields container)

Description

Computes the element-wise invariants of all the tensor fields of a fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_intname
(fields_container)expected type(s)

stress intensity field

pin 1requested
fields_eqvname
(fields_container)expected type(s)

stress equivalent intensity

pin 2requested
fields_max_shearname
(fields_container)expected type(s)

max shear stress field

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: invariant
  • plugin: core
  • scripting name: invariants_fc
  • full name: invariant.invariants_fc
  • internal name: invariants_deriv_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.invariants_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_int = op.outputs.fields_int.GetData()
my_fields_eqv = op.outputs.fields_eqv.GetData()
my_fields_max_shear = op.outputs.fields_max_shear.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.invariants_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_int = op.outputs.fields_int()
my_fields_eqv = op.outputs.fields_eqv()
my_fields_max_shear = op.outputs.fields_max_shear()
#include "dpf_api.h"

ansys::dpf::Operator op("invariants_deriv_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_int = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_fields_eqv = op.getOutput<ansys::dpf::FieldsContainer>(1);
ansys::dpf::FieldsContainer my_fields_max_shear = op.getOutput<ansys::dpf::FieldsContainer>(2);

math: cross product (fields container)

Description

Computes the cross product of two vector fields. Fields can have the same location or Elemental Nodal and Nodal locations.

Inputs

pin 0requested
field_or_fields_container_Aname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

pin 1requested
field_or_fields_container_Bname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: cross_product_fc
  • full name: math.cross_product_fc
  • internal name: cross_product_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.cross_product_fc() # operator instantiation
op.inputs.field_or_fields_container_A.Connect(my_field_or_fields_container_A)
op.inputs.field_or_fields_container_B.Connect(my_field_or_fields_container_B)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.cross_product_fc() # operator instantiation
op.inputs.field_or_fields_container_A.connect(my_field_or_fields_container_A)
op.inputs.field_or_fields_container_B.connect(my_field_or_fields_container_B)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("cross_product_fc"); // operator instantiation
op.connect(0, my_field_or_fields_container_A);
op.connect(1, my_field_or_fields_container_B);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: -

Description

Computes the difference of two fields. If one field's scoping has an 'overall' location, then this field's values are applied on the other field entirely. When using a constant or 'work_by_index', you can use 'inplace' to reuse one of the fields.

Inputs

pin 0requested
fieldAname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

pin 1requested
fieldBname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
inplaceThe output is written over the input to save memory if this config is set to true.
(bool)expected type(s)
falsedefault value
: The output is written over the input to save memory if this config is set to true.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: minus
  • full name: math.minus
  • internal name: minus
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.minus() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.minus() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("minus"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: plastic strain principal 1

Description

Read/compute element nodal component plastic strains 1st principal component by calling the readers defined by the datasources and computing its eigen values. The off-diagonal strains are first converted from Voigt notation to the standard strain values.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain_principal_1
  • full name: result.plastic_strain_principal_1
  • internal name: EPPL1
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_principal_1() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_principal_1() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPPL1"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: total sum

Description

Sums all the elementary data of a field to produce one elementary data point.

Inputs

pin 0requested
fieldAname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
weightsname
(field)expected type(s)

Field containing weights, one weight per entity

pin 2optional
time_scopingname
(scoping)expected type(s)

time_scoping

Outputs

pin 0requested
fieldname
(field)expected type(s)

Field containing the (weighted) sum for each component in an elementary data

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: accumulate
  • full name: math.accumulate
  • internal name: accumulate
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.accumulate() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.weights.Connect(my_weights)
op.inputs.time_scoping.Connect(my_time_scoping)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.accumulate() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.weights.connect(my_weights)
op.inputs.time_scoping.connect(my_time_scoping)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("accumulate"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_weights);
op.connect(2, my_time_scoping);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: - (fields container)

Description

Computes the difference of two fields. If one field's scoping has an 'overall' location, then this field's values are applied on the other field entirely. When using a constant or 'work_by_index', you can use 'inplace' to reuse one of the fields.

Inputs

pin 0requested
field_or_fields_container_Aname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

pin 1requested
field_or_fields_container_Bname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
inplaceThe output is written over the input to save memory if this config is set to true.
(bool)expected type(s)
falsedefault value
: The output is written over the input to save memory if this config is set to true.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: minus_fc
  • full name: math.minus_fc
  • internal name: minus_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.minus_fc() # operator instantiation
op.inputs.field_or_fields_container_A.Connect(my_field_or_fields_container_A)
op.inputs.field_or_fields_container_B.Connect(my_field_or_fields_container_B)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.minus_fc() # operator instantiation
op.inputs.field_or_fields_container_A.connect(my_field_or_fields_container_A)
op.inputs.field_or_fields_container_B.connect(my_field_or_fields_container_B)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("minus_fc"); // operator instantiation
op.connect(0, my_field_or_fields_container_A);
op.connect(1, my_field_or_fields_container_B);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

scoping: elements in mesh

Description

Retrieves the elemental scoping of a given input mesh, which contains the element IDs.

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
mesh_scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: elemental_from_mesh
  • full name: scoping.elemental_from_mesh
  • internal name: GetElementScopingFromMesh
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.elemental_from_mesh() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
my_mesh_scoping = op.outputs.mesh_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.elemental_from_mesh() # operator instantiation
op.inputs.mesh.connect(my_mesh)
my_mesh_scoping = op.outputs.mesh_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("GetElementScopingFromMesh"); // operator instantiation
op.connect(0, my_mesh);
ansys::dpf::Scoping my_mesh_scoping = op.getOutput<ansys::dpf::Scoping>(0);

scoping: intersect scopings

Description

Intersect 2 scopings and return the intersection and the difference between the intersection and the first scoping.

Inputs

pin 0requested
scopingAname
(scoping)expected type(s)
pin 1requested
scopingBname
(scoping)expected type(s)

Outputs

pin 0requested
intersectionname
(scoping)expected type(s)
pin 1requested
scopingA_min_intersectionname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: intersect
  • full name: scoping.intersect
  • internal name: scoping::intersect
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.intersect() # operator instantiation
op.inputs.scopingA.Connect(my_scopingA)
op.inputs.scopingB.Connect(my_scopingB)
my_intersection = op.outputs.intersection.GetData()
my_scopingA_min_intersection = op.outputs.scopingA_min_intersection.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.intersect() # operator instantiation
op.inputs.scopingA.connect(my_scopingA)
op.inputs.scopingB.connect(my_scopingB)
my_intersection = op.outputs.intersection()
my_scopingA_min_intersection = op.outputs.scopingA_min_intersection()
#include "dpf_api.h"

ansys::dpf::Operator op("scoping::intersect"); // operator instantiation
op.connect(0, my_scopingA);
op.connect(1, my_scopingB);
ansys::dpf::Scoping my_intersection = op.getOutput<ansys::dpf::Scoping>(0);
ansys::dpf::Scoping my_scopingA_min_intersection = op.getOutput<ansys::dpf::Scoping>(1);

math: ^ (field)

Description

Computes element-wise field[i]^p.

Inputs

pin 0requested
fieldname
(field)expected type(s)
pin 1requested
factorname
(double)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: pow
  • full name: math.pow
  • internal name: Pow
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.pow() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.factor.Connect(my_factor)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.pow() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.factor.connect(my_factor)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("Pow"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_factor);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: scale (field)

Description

Scales a field by a constant factor. This factor can be a scalar or a vector, where each value of the vector represents a scaler per component. Number of the components are corresponding to the input field dimensionality

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
weightsname
(double | field | vector)expected type(s)

Double/Field/Vector of doubles. When scoped on overall, same value(s) applied on all the data, when scoped elsewhere, corresponding values will be multiplied due to the scoping

pin 2optional
booleanname
(bool)expected type(s)

Default is false. If set to true, output of scale is made dimensionless

pin 3optional
algorithmname
(int32)expected type(s)

Default is 0 use mkl. If set to 1, don't

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.

Scripting

  • category: math
  • plugin: core
  • scripting name: scale
  • full name: math.scale
  • internal name: scale
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.scale() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.weights.Connect(my_weights)
op.inputs.boolean.Connect(my_boolean)
op.inputs.algorithm.Connect(my_algorithm)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.scale() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.weights.connect(my_weights)
op.inputs.boolean.connect(my_boolean)
op.inputs.algorithm.connect(my_algorithm)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("scale"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_weights);
op.connect(2, my_boolean);
op.connect(3, my_algorithm);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: enthalpy

Description

Read Enthalpy by calling the readers defined by the datasources.

Supported file types

  • cff: flprj,cas

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: enthalpy
  • full name: result.enthalpy
  • internal name: H_S
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.enthalpy() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.enthalpy() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("H_S"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: ^ (fields container)

Description

Computes element-wise field[i]^p.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
factorname
(double)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: pow_fc
  • full name: math.pow_fc
  • internal name: Pow_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.pow_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.factor.Connect(my_factor)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.pow_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.factor.connect(my_factor)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("Pow_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_factor);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global eroded internal energy (LSDyna)

Description

Read Global Eroded Internal Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_eroded_internal_energy
  • full name: result.global_eroded_internal_energy
  • internal name: GLOB_ERIE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_eroded_internal_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_eroded_internal_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_ERIE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: scale fields container

Description

Scales a fields container by a constant factor. This factor can be a scalar, a vector a field, a fields container, where each value of the vector represents a scaler per component. Number of the components are corresponding to the input field dimensionality

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

fields container to be scaled

pin 1requested
weightsname
(double | field | vector | fields_container)expected type(s)

Double/Vector of doubles/Field/FieldsContainer. When scoped on overall, same value(s) applied on all the data, when scoped elsewhere, corresponding values will be multiplied due to the scoping

pin 2optional
booleanname
(bool)expected type(s)

Default is false. If set to true, output of scale is made dimensionless

pin 3optional
algorithmname
(int32)expected type(s)

Default is 0 use mkl. If set to 1, don't

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: math
  • plugin: core
  • scripting name: scale_fc
  • full name: math.scale_fc
  • internal name: scale_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.scale_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.weights.Connect(my_weights)
op.inputs.boolean.Connect(my_boolean)
op.inputs.algorithm.Connect(my_algorithm)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.scale_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.weights.connect(my_weights)
op.inputs.boolean.connect(my_boolean)
op.inputs.algorithm.connect(my_algorithm)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("scale_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_weights);
op.connect(2, my_boolean);
op.connect(3, my_algorithm);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: sweeping phase

Description

Shifts the phase of a real and an imaginary field (in 0 and 1) of a given angle (in 3) of a unit (in 4).

Inputs

pin 0requested
real_fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
imaginary_fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 2requested
anglename
(double)expected type(s)
pin 3optional
unit_namename
(string)expected type(s)

String Unit. Supported values: "deg" or "rad". Default: "rad".

pin 4requested
abs_valuename
(bool)expected type(s)
pin 5requested
imaginary_part_nullname
(bool)expected type(s)

If the imaginary part field is empty and this pin is true, then the imaginary part is supposed to be 0 (default is false).

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: sweeping_phase
  • full name: math.sweeping_phase
  • internal name: sweeping_phase
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.sweeping_phase() # operator instantiation
op.inputs.real_field.Connect(my_real_field)
op.inputs.imaginary_field.Connect(my_imaginary_field)
op.inputs.angle.Connect(my_angle)
op.inputs.unit_name.Connect(my_unit_name)
op.inputs.abs_value.Connect(my_abs_value)
op.inputs.imaginary_part_null.Connect(my_imaginary_part_null)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.sweeping_phase() # operator instantiation
op.inputs.real_field.connect(my_real_field)
op.inputs.imaginary_field.connect(my_imaginary_field)
op.inputs.angle.connect(my_angle)
op.inputs.unit_name.connect(my_unit_name)
op.inputs.abs_value.connect(my_abs_value)
op.inputs.imaginary_part_null.connect(my_imaginary_part_null)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("sweeping_phase"); // operator instantiation
op.connect(0, my_real_field);
op.connect(1, my_imaginary_field);
op.connect(2, my_angle);
op.connect(3, my_unit_name);
op.connect(4, my_abs_value);
op.connect(5, my_imaginary_part_null);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: centroid

Description

Computes centroid of field1 and field2, using fieldOut = field1*(1.-fact)+field2*(fact). Only works by index.

Inputs

pin 0requested
fieldAname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
fieldBname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 2requested
factorname
(double)expected type(s)

Scalar

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
truedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: centroid
  • full name: math.centroid
  • internal name: centroid
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.centroid() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
op.inputs.factor.Connect(my_factor)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.centroid() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
op.inputs.factor.connect(my_factor)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("centroid"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
op.connect(2, my_factor);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

filter: signed high pass (field)

Description

The high pass filter returns all the values above, or equal, in absolute value to the threshold value in input.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
thresholdname
(double | field)expected type(s)

A threshold scalar or a field containing one value is expected.

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: field_signed_high_pass
  • full name: filter.field_signed_high_pass
  • internal name: core::field::signed_high_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.field_signed_high_pass() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.field_signed_high_pass() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("core::field::signed_high_pass"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: sweeping phase (fields container)

Description

Shifts the phase of all the corresponding real and imaginary fields of a fields container for a given angle (in 2) of a unit (in 4).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 2requested
anglename
(double)expected type(s)
pin 3optional
unit_namename
(string)expected type(s)

String Unit. Supported values: "deg" or "rad". Default: "rad".

pin 4requested
abs_valuename
(bool)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: sweeping_phase_fc
  • full name: math.sweeping_phase_fc
  • internal name: sweeping_phase_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.sweeping_phase_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.angle.Connect(my_angle)
op.inputs.unit_name.Connect(my_unit_name)
op.inputs.abs_value.Connect(my_abs_value)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.sweeping_phase_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.angle.connect(my_angle)
op.inputs.unit_name.connect(my_unit_name)
op.inputs.abs_value.connect(my_abs_value)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("sweeping_phase_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(2, my_angle);
op.connect(3, my_unit_name);
op.connect(4, my_abs_value);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: centroid (fields container)

Description

Computes the centroid of all the matching fields of a fields container at a given time or frequency, using fieldOut = field1*(1.-fact)+field2*(fact).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
time_freqname
(double)expected type(s)
pin 2optional
stepname
(int32)expected type(s)
pin 8optional
time_freq_supportname
(time_freq_support)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.

Scripting

  • category: math
  • plugin: core
  • scripting name: centroid_fc
  • full name: math.centroid_fc
  • internal name: centroid_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.centroid_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.time_freq.Connect(my_time_freq)
op.inputs.step.Connect(my_step)
op.inputs.time_freq_support.Connect(my_time_freq_support)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.centroid_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.time_freq.connect(my_time_freq)
op.inputs.step.connect(my_step)
op.inputs.time_freq_support.connect(my_time_freq_support)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("centroid_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_time_freq);
op.connect(2, my_step);
op.connect(8, my_time_freq_support);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: ^2 (field)

Description

Computes element-wise field[i]^2.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

inplaceThe output is written over the input to save memory if this config is set to true.
(bool)expected type(s)
falsedefault value
: The output is written over the input to save memory if this config is set to true.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: math
  • plugin: core
  • scripting name: sqr
  • full name: math.sqr
  • internal name: sqr
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.sqr() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.sqr() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("sqr"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: reaction force Z

Description

Read/compute nodal reaction forces Z component of the vector (3rd component) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: reaction_force_Z
  • full name: result.reaction_force_Z
  • internal name: RFZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.reaction_force_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.reaction_force_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("RFZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: velocity Z

Description

Read/compute nodal velocities Z component of the vector (3rd component) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: velocity_Z
  • full name: result.velocity_Z
  • internal name: VZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.velocity_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.velocity_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("VZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: remove unnecessary labels

Description

Removes the selected label from a fields container.

Inputs

pin -1optional
permissivename
(bool)expected type(s)

If true, the operator does not throw an error if the label to be removed has more than one entry.

pin 0requested
fields_containername
(fields_container)expected type(s)

Fields Container with the label to be removed.

pin 1requested
label_to_removename
(string)expected type(s)

Label to be removed from the fields container.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
read_inputs_in_parallelIf this option is set to true, the operator's inputs will be evaluated in parallel.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the operator's inputs will be evaluated in parallel.

Scripting

  • category: utility
  • plugin: core
  • scripting name: remove_unnecessary_labels
  • full name: utility.remove_unnecessary_labels
  • internal name: remove_unnecessary_label
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.remove_unnecessary_labels() # operator instantiation
op.inputs.permissive.Connect(my_permissive)
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.label_to_remove.Connect(my_label_to_remove)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.remove_unnecessary_labels() # operator instantiation
op.inputs.permissive.connect(my_permissive)
op.inputs.fields_container.connect(my_fields_container)
op.inputs.label_to_remove.connect(my_label_to_remove)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("remove_unnecessary_label"); // operator instantiation
op.connect(-1, my_permissive);
op.connect(0, my_fields_container);
op.connect(1, my_label_to_remove);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: sin (field)

Description

Computes element-wise sin(field[i]).

Inputs

pin 0requested
fieldname
(field)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: sin
  • full name: math.sin
  • internal name: sin
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.sin() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.sin() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("sin"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: cos (field)

Description

Computes element-wise cos(field[i]).

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: cos
  • full name: math.cos
  • internal name: cos
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.cos() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.cos() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("cos"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

logic: ascending sort

Description

Sort a field (in 0) in ascending order with an optional component priority table, or a boolean, to enable sort by scoping (in 1). This operator does not support multiple elementary data per entity.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
component_priority_tablename
(vector)expected type(s)

component priority table (vector of int)

pin 2optional
sort_by_scopingname
(bool)expected type(s)

if true, uses scoping to sort the field (default is false)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: ascending_sort
  • full name: logic.ascending_sort
  • internal name: ascending_sort
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.ascending_sort() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.component_priority_table.Connect(my_component_priority_table)
op.inputs.sort_by_scoping.Connect(my_sort_by_scoping)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.ascending_sort() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.component_priority_table.connect(my_component_priority_table)
op.inputs.sort_by_scoping.connect(my_sort_by_scoping)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("ascending_sort"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_component_priority_table);
op.connect(2, my_sort_by_scoping);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: cos (fields container)

Description

Computes element-wise cos(field[i]).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: cos_fc
  • full name: math.cos_fc
  • internal name: cos_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.cos_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.cos_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("cos_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: initial coordinates (LSDyna)

Description

Read/compute Initial Coordinates (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: initial_coordinates
  • full name: result.initial_coordinates
  • internal name: XI
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.initial_coordinates() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.initial_coordinates() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("XI"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: convert to fields container

Description

Creates a fields container containing the field provided on pin 0.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

If a fields container is set in input, it is passed on as an output with the additional label space (if any).

pin 1requested
labelname
(label_space)expected type(s)

Sets a label space.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: field_to_fc
  • full name: utility.field_to_fc
  • internal name: InjectToFieldContainer
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.field_to_fc() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.label.Connect(my_label)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.field_to_fc() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.label.connect(my_label)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("InjectToFieldContainer"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_label);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: linear combination

Description

Computes aXY + bZ where a,b (in 0, in 3) are scalar and X,Y,Z (in 1,2,4) are complex numbers.

Inputs

pin 0requested
aname
(double)expected type(s)

Double

pin 1requested
fields_containerAname
(fields_container)expected type(s)
pin 2requested
fields_containerBname
(fields_container)expected type(s)
pin 3requested
bname
(double)expected type(s)

Double

pin 4requested
fields_containerCname
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: linear_combination
  • full name: math.linear_combination
  • internal name: CplxOp
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.linear_combination() # operator instantiation
op.inputs.a.Connect(my_a)
op.inputs.fields_containerA.Connect(my_fields_containerA)
op.inputs.fields_containerB.Connect(my_fields_containerB)
op.inputs.b.Connect(my_b)
op.inputs.fields_containerC.Connect(my_fields_containerC)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.linear_combination() # operator instantiation
op.inputs.a.connect(my_a)
op.inputs.fields_containerA.connect(my_fields_containerA)
op.inputs.fields_containerB.connect(my_fields_containerB)
op.inputs.b.connect(my_b)
op.inputs.fields_containerC.connect(my_fields_containerC)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("CplxOp"); // operator instantiation
op.connect(0, my_a);
op.connect(1, my_fields_containerA);
op.connect(2, my_fields_containerB);
op.connect(3, my_b);
op.connect(4, my_fields_containerC);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: ^2 (fields container)

Description

Computes element-wise field[i]^2.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

inplaceThe output is written over the input to save memory if this config is set to true.
(bool)expected type(s)
falsedefault value
: The output is written over the input to save memory if this config is set to true.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: math
  • plugin: core
  • scripting name: sqr_fc
  • full name: math.sqr_fc
  • internal name: sqr_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.sqr_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.sqr_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("sqr_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: mean static pressure

Description

Read Mean Static Pressure by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: mean_static_pressure
  • full name: result.mean_static_pressure
  • internal name: P_SA
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mean_static_pressure() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mean_static_pressure() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("P_SA"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: exp (field)

Description

Computes element-wise exp(field[i]).

Inputs

pin 0requested
fieldname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: exponential
  • full name: math.exponential
  • internal name: exponential
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.exponential() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.exponential() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("exponential"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: exp (fields container)

Description

Computes element-wise exp(field[i]).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: exponential_fc
  • full name: math.exponential_fc
  • internal name: exponential_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.exponential_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.exponential_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("exponential_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: * (component-wise field)

Description

Computes component-wise product between two fields of same dimensionality. If one field's scoping has an 'overall' location, then this field's values are applied on the other field entirely. When using a constant or 'work_by_index', you can use 'inplace' to reuse one of the fields.

Inputs

pin 0requested
fieldAname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
fieldBname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
inplaceThe output is written over the input to save memory if this config is set to true.
(bool)expected type(s)
falsedefault value
: The output is written over the input to save memory if this config is set to true.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: component_wise_product
  • full name: math.component_wise_product
  • internal name: component_wise_product
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.component_wise_product() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.component_wise_product() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("component_wise_product"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: stress max_shear

Description

Reads/computes element nodal component stresses, average it on nodes (by default) and computes its invariants.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress_max_shear
  • full name: result.stress_max_shear
  • internal name: S_max_shear
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_max_shear() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_max_shear() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("S_max_shear"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

logic: same meshes container?

Description

Checks if two meshes_container are identical.

Inputs

pin 0requested
meshes_containerAname
(meshes_container)expected type(s)
pin 1requested
meshes_containerBname
(meshes_container)expected type(s)
pin 2optional
small_valuename
(double)expected type(s)

Double positive small value. Smallest value which will be considered during the comparison step. All the abs(values) in the field less than this value are considered as null, (default value:1.0e-14).

pin 3optional
tolerancename
(double)expected type(s)

Double relative tolerance. Maximum tolerance gap between two compared values. Values within relative tolerance are considered identical (v1-v2)/v2 < relativeTol (default is 0.001).

pin 4requested
compare_auxiliaryname
(bool)expected type(s)

compare auxiliary data (i.e property fields, scopings...). Default value is 'false'.

Outputs

pin 0requested
booleanname
(bool)expected type(s)

bool (true if identical...)

pin 1requested
messagename
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: identical_mc
  • full name: logic.identical_mc
  • internal name: compare::meshes_container
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.identical_mc() # operator instantiation
op.inputs.meshes_containerA.Connect(my_meshes_containerA)
op.inputs.meshes_containerB.Connect(my_meshes_containerB)
op.inputs.small_value.Connect(my_small_value)
op.inputs.tolerance.Connect(my_tolerance)
op.inputs.compare_auxiliary.Connect(my_compare_auxiliary)
my_boolean = op.outputs.boolean.GetData()
my_message = op.outputs.message.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.identical_mc() # operator instantiation
op.inputs.meshes_containerA.connect(my_meshes_containerA)
op.inputs.meshes_containerB.connect(my_meshes_containerB)
op.inputs.small_value.connect(my_small_value)
op.inputs.tolerance.connect(my_tolerance)
op.inputs.compare_auxiliary.connect(my_compare_auxiliary)
my_boolean = op.outputs.boolean()
my_message = op.outputs.message()
#include "dpf_api.h"

ansys::dpf::Operator op("compare::meshes_container"); // operator instantiation
op.connect(0, my_meshes_containerA);
op.connect(1, my_meshes_containerB);
op.connect(2, my_small_value);
op.connect(3, my_tolerance);
op.connect(4, my_compare_auxiliary);
bool my_boolean = op.getOutput<bool>(0);
std::string my_message = op.getOutput<std::string>(1);

math: * (component-wise field) (fields container)

Description

Computes component-wise product between two fields of same dimensionality. If one field's scoping has an 'overall' location, then this field's values are applied on the other field entirely. When using a constant or 'work_by_index', you can use 'inplace' to reuse one of the fields.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
fieldBname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
inplaceThe output is written over the input to save memory if this config is set to true.
(bool)expected type(s)
falsedefault value
: The output is written over the input to save memory if this config is set to true.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: component_wise_product_fc
  • full name: math.component_wise_product_fc
  • internal name: component_wise_product_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.component_wise_product_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.fieldB.Connect(my_fieldB)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.component_wise_product_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.fieldB.connect(my_fieldB)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("component_wise_product_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_fieldB);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: euler nodes

Description

Reads a field made of 3 coordinates and 3 Euler angles (6 dofs) by node from the result file.

Supported file types

  • hdf5: h5dpf
  • mapdl: rth,rst,mode

Inputs

pin 3optional
streams_containername
(streams_container | stream)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)
pin 5requested
filter_zerosname
(bool)expected type(s)

if true, then the field will only contain the scoping if any rotation is not zero. (default is false).

pin 6requested
coord_and_eulername
(bool)expected type(s)

if true, then the field has ncomp=6 with 3 coordinates and 3 Euler angles, else there is only the Euler angles (default is true).

pin 7optional
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: euler_nodes
  • full name: result.euler_nodes
  • internal name: coords_and_euler_nodes
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.euler_nodes() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.filter_zeros.Connect(my_filter_zeros)
op.inputs.coord_and_euler.Connect(my_coord_and_euler)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.euler_nodes() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.filter_zeros.connect(my_filter_zeros)
op.inputs.coord_and_euler.connect(my_coord_and_euler)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("coords_and_euler_nodes"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_filter_zeros);
op.connect(6, my_coord_and_euler);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: beam TR shear stress (LSDyna)

Description

Read Beam TR Shear Stress (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
integration_pointname
(int32)expected type(s)

integration point where the result will be read from. Default value: 0 (first integration point).

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: beam_tr_shear_stress
  • full name: result.beam_tr_shear_stress
  • internal name: B_ST2
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.beam_tr_shear_stress() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.integration_point.Connect(my_integration_point)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.beam_tr_shear_stress() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.integration_point.connect(my_integration_point)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("B_ST2"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_integration_point);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: num surface status changes

Description

Read/compute element total number of contact status changes during substep by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: num_surface_status_changes
  • full name: result.num_surface_status_changes
  • internal name: ECT_CNOS
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.num_surface_status_changes() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.num_surface_status_changes() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ECT_CNOS"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: ln (field)

Description

Computes element-wise ln(field[i]).

Inputs

pin 0requested
fieldname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: ln
  • full name: math.ln
  • internal name: ln
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.ln() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.ln() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("ln"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

mesh: mesh to pyvista

Description

Export a MeshedRegion in the pyVista format.

Inputs

pin 2optional
coordinatesname
(field)expected type(s)

Node coordinates. If not set, the node coordinates of the mesh are employed.

pin 6optional
as_linearname
(bool)expected type(s)

Export a linear version of the mesh (quadratic surface elements do no include midside nodes). If not set, defaults to true.

pin 7requested
meshname
(abstract_meshed_region)expected type(s)

mesh to export in pyVista format

pin 60optional
vtk_updatedname
(bool)expected type(s)

True if the VTK version employed by pyVista is > VTK 9. Default true.

pin 200optional
as_polyname
(bool)expected type(s)

Export elements as polyhedrons (cell-face-node representation). Default false.

Outputs

pin 0requested
nodesname
(field)expected type(s)

Node coordinates double vector

pin 1requested
cellsname
(vector)expected type(s)

Cell connectivity int vector

pin 2requested
cell_typesname
(vector)expected type(s)

Cell types property int vector

pin 3optional
offsetsname
(vector)expected type(s)

If vtk_updated=false, offsets int vector

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: vtk
  • scripting name: mesh_to_pyvista
  • full name: mesh.mesh_to_pyvista
  • internal name: mesh_to_pyvista
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.mesh_to_pyvista() # operator instantiation
op.inputs.coordinates.Connect(my_coordinates)
op.inputs.as_linear.Connect(my_as_linear)
op.inputs.mesh.Connect(my_mesh)
op.inputs.vtk_updated.Connect(my_vtk_updated)
op.inputs.as_poly.Connect(my_as_poly)
my_nodes = op.outputs.nodes.GetData()
my_cells = op.outputs.cells.GetData()
my_cell_types = op.outputs.cell_types.GetData()
my_offsets = op.outputs.offsets.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.mesh_to_pyvista() # operator instantiation
op.inputs.coordinates.connect(my_coordinates)
op.inputs.as_linear.connect(my_as_linear)
op.inputs.mesh.connect(my_mesh)
op.inputs.vtk_updated.connect(my_vtk_updated)
op.inputs.as_poly.connect(my_as_poly)
my_nodes = op.outputs.nodes()
my_cells = op.outputs.cells()
my_cell_types = op.outputs.cell_types()
my_offsets = op.outputs.offsets()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh_to_pyvista"); // operator instantiation
op.connect(2, my_coordinates);
op.connect(6, my_as_linear);
op.connect(7, my_mesh);
op.connect(60, my_vtk_updated);
op.connect(200, my_as_poly);
ansys::dpf::Field my_nodes = op.getOutput<ansys::dpf::Field>(0);
std::vector my_cells = op.getOutput<std::vector>(1);
std::vector my_cell_types = op.getOutput<std::vector>(2);
std::vector my_offsets = op.getOutput<std::vector>(3);

invariant: scalar invariants (field)

Description

Computes the element-wise invariants of a tensor field.

Inputs

pin 0requested
fieldname
(field)expected type(s)

Outputs

pin 0requested
field_intname
(field)expected type(s)

stress intensity field

pin 1requested
field_eqvname
(field)expected type(s)

stress equivalent intensity

pin 2requested
field_max_shearname
(field)expected type(s)

max shear stress field

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: invariant
  • plugin: core
  • scripting name: invariants
  • full name: invariant.invariants
  • internal name: invariants_deriv
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.invariants() # operator instantiation
op.inputs.field.Connect(my_field)
my_field_int = op.outputs.field_int.GetData()
my_field_eqv = op.outputs.field_eqv.GetData()
my_field_max_shear = op.outputs.field_max_shear.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.invariants() # operator instantiation
op.inputs.field.connect(my_field)
my_field_int = op.outputs.field_int()
my_field_eqv = op.outputs.field_eqv()
my_field_max_shear = op.outputs.field_max_shear()
#include "dpf_api.h"

ansys::dpf::Operator op("invariants_deriv"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field_int = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_field_eqv = op.getOutput<ansys::dpf::Field>(1);
ansys::dpf::Field my_field_max_shear = op.getOutput<ansys::dpf::Field>(2);

math: ln (fields container)

Description

Computes element-wise ln(field[i]).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: ln_fc
  • full name: math.ln_fc
  • internal name: ln_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.ln_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.ln_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ln_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: cross product

Description

Computes the cross product of two vector fields. Fields can have the same location or Elemental Nodal and Nodal locations.

Inputs

pin 0requested
fieldAname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

pin 1requested
fieldBname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: cross_product
  • full name: math.cross_product
  • internal name: cross_product
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.cross_product() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.cross_product() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("cross_product"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

filter: high pass (timefreq)

Description

The high pass filter returns all the values above (but not equal to) the threshold value in input.

Inputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1requested
thresholdname
(double | field)expected type(s)

A threshold scalar or a field containing one value is expected.

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: timefreq_high_pass
  • full name: filter.timefreq_high_pass
  • internal name: core::timefreq::high_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.timefreq_high_pass() # operator instantiation
op.inputs.time_freq_support.Connect(my_time_freq_support)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_time_freq_support = op.outputs.time_freq_support.GetData()
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.timefreq_high_pass() # operator instantiation
op.inputs.time_freq_support.connect(my_time_freq_support)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_time_freq_support = op.outputs.time_freq_support()
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("core::timefreq::high_pass"); // operator instantiation
op.connect(0, my_time_freq_support);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::TimeFreqSupport my_time_freq_support = op.getOutput<ansys::dpf::TimeFreqSupport>(0);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(1);

math: / (component-wise fields container)

Description

For every two fields with the same label space (from the two input fields containers), computes component-wise fraction between two fields of same dimensionality. If one field's scoping has an 'overall' location, then this field's values are applied on the other field entirely.

Inputs

pin 0requested
fields_containerAname
(fields_container)expected type(s)
pin 1requested
fields_containerBname
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: component_wise_divide_fc
  • full name: math.component_wise_divide_fc
  • internal name: component_wise_divide_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.component_wise_divide_fc() # operator instantiation
op.inputs.fields_containerA.Connect(my_fields_containerA)
op.inputs.fields_containerB.Connect(my_fields_containerB)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.component_wise_divide_fc() # operator instantiation
op.inputs.fields_containerA.connect(my_fields_containerA)
op.inputs.fields_containerB.connect(my_fields_containerB)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("component_wise_divide_fc"); // operator instantiation
op.connect(0, my_fields_containerA);
op.connect(1, my_fields_containerB);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: kronecker product

Description

Computes element-wise Kronecker product between two tensor fields.

Inputs

pin 0requested
fieldAname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
fieldBname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: math
  • plugin: core
  • scripting name: kronecker_prod
  • full name: math.kronecker_prod
  • internal name: kronecker_prod
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.kronecker_prod() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.kronecker_prod() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("kronecker_prod"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: global sliding interface energy (LSDyna)

Description

Read Global Sliding Interface Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_sliding_interface_energy
  • full name: result.global_sliding_interface_energy
  • internal name: GLOB_SIE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_sliding_interface_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_sliding_interface_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_SIE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: modulus (fields container)

Description

Computes amplitude of a real and an imaginary field.

Inputs

pin 0requested
fieldAname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
fieldBname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: amplitude
  • full name: math.amplitude
  • internal name: amplitude
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.amplitude() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.amplitude() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("amplitude"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: dot (complex fields)

Description

Computes product between two field containers containing complex fields.

Inputs

pin 0requested
fields_containerAname
(fields_container)expected type(s)
pin 1requested
fields_containerBname
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: cplx_dot
  • full name: math.cplx_dot
  • internal name: cplx_dot
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.cplx_dot() # operator instantiation
op.inputs.fields_containerA.Connect(my_fields_containerA)
op.inputs.fields_containerB.Connect(my_fields_containerB)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.cplx_dot() # operator instantiation
op.inputs.fields_containerA.connect(my_fields_containerA)
op.inputs.fields_containerB.connect(my_fields_containerB)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("cplx_dot"); // operator instantiation
op.connect(0, my_fields_containerA);
op.connect(1, my_fields_containerB);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: joint relative angular velocity

Description

Read/compute joint relative angular velocity by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: joint_relative_angular_velocity
  • full name: result.joint_relative_angular_velocity
  • internal name: JOMG
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.joint_relative_angular_velocity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.joint_relative_angular_velocity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("JOMG"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: gasket stress XZ

Description

Read/compute elemental gasket stress XZ shear component (02 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_stress_XZ
  • full name: result.gasket_stress_XZ
  • internal name: GKSXZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_stress_XZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_stress_XZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKSXZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: / (complex fields)

Description

Computes division between two field containers containing complex fields.

Inputs

pin 0requested
fields_containerAname
(fields_container)expected type(s)
pin 1requested
fields_containerBname
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: cplx_divide
  • full name: math.cplx_divide
  • internal name: cplx_divide
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.cplx_divide() # operator instantiation
op.inputs.fields_containerA.Connect(my_fields_containerA)
op.inputs.fields_containerB.Connect(my_fields_containerB)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.cplx_divide() # operator instantiation
op.inputs.fields_containerA.connect(my_fields_containerA)
op.inputs.fields_containerB.connect(my_fields_containerB)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("cplx_divide"); // operator instantiation
op.connect(0, my_fields_containerA);
op.connect(1, my_fields_containerB);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: unitary field

Description

Takes a field and returns another field of scalars in the same location and scoping as the input field.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: unitary_field
  • full name: utility.unitary_field
  • internal name: make_unit
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.unitary_field() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.unitary_field() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("make_unit"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: server path

Description

Returns the platform-specific path to a folder in the Dpf server

Inputs

pin 0optional
subpathname
(int32)expected type(s)

Subpath of the Dpf server. Supported values: 0 (default): root of the server, 1: "dpf/bin/platform", 2: "aisol/bin(dll)/platform", 3: "dpf/plugins", 4: "dpf/workflows".

Outputs

pin 0requested
pathname
(string)expected type(s)

Path to the requested folder in the Dpf server

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: server_path
  • full name: utility.server_path
  • internal name: server_path
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.server_path() # operator instantiation
op.inputs.subpath.Connect(my_subpath)
my_path = op.outputs.path.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.server_path() # operator instantiation
op.inputs.subpath.connect(my_subpath)
my_path = op.outputs.path()
#include "dpf_api.h"

ansys::dpf::Operator op("server_path"); // operator instantiation
op.connect(0, my_subpath);
std::string my_path = op.getOutput<std::string>(0);

result: beam axial force (LSDyna)

Description

Read Beam Axial Force (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: beam_axial_force
  • full name: result.beam_axial_force
  • internal name: B_N
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.beam_axial_force() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.beam_axial_force() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("B_N"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: derivate (complex fields)

Description

Derives field containers containing complex fields.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

inplaceThe output is written over the input to save memory if this config is set to true.
(bool)expected type(s)
falsedefault value
: The output is written over the input to save memory if this config is set to true.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: math
  • plugin: core
  • scripting name: cplx_derive
  • full name: math.cplx_derive
  • internal name: cplx_derive
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.cplx_derive() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.cplx_derive() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("cplx_derive"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: polar to complex fields

Description

Converts a complex number from polar form to complex.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: polar_to_cplx
  • full name: math.polar_to_cplx
  • internal name: polar_to_cplx
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.polar_to_cplx() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.polar_to_cplx() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("polar_to_cplx"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: dot (fields container)

Description

Computes a general notion of inner product between two fields of possibly different dimensionality.

Inputs

pin 0requested
field_or_fields_container_Aname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

pin 1requested
field_or_fields_container_Bname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: generalized_inner_product_fc
  • full name: math.generalized_inner_product_fc
  • internal name: generalized_inner_product_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.generalized_inner_product_fc() # operator instantiation
op.inputs.field_or_fields_container_A.Connect(my_field_or_fields_container_A)
op.inputs.field_or_fields_container_B.Connect(my_field_or_fields_container_B)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.generalized_inner_product_fc() # operator instantiation
op.inputs.field_or_fields_container_A.connect(my_field_or_fields_container_A)
op.inputs.field_or_fields_container_B.connect(my_field_or_fields_container_B)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("generalized_inner_product_fc"); // operator instantiation
op.connect(0, my_field_or_fields_container_A);
op.connect(1, my_field_or_fields_container_B);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: nodal moment

Description

Read/compute nodal moment by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: nodal_moment
  • full name: result.nodal_moment
  • internal name: M
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.nodal_moment() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.nodal_moment() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("M"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: phase (field)

Description

Computes the phase (in rad) between a real and an imaginary field.

Inputs

pin 0requested
fieldAname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
fieldBname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: phase
  • full name: math.phase
  • internal name: phase
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.phase() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.phase() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("phase"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: phase (fields container)

Description

Computes phase (in rad) between real and imaginary fields.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: phase_fc
  • full name: math.phase_fc
  • internal name: phase_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.phase_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.phase_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("phase_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: modulus (field)

Description

Computes element-wise modulus of field containers containing complex fields.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: modulus
  • full name: math.modulus
  • internal name: modulus
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.modulus() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.modulus() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("modulus"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elemental mass

Description

Read/compute element mass by calling the readers defined by the datasources.

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elemental_mass
  • full name: result.elemental_mass
  • internal name: ElementalMass
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elemental_mass() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elemental_mass() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ElementalMass"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: total sum (fields container)

Description

Sums all the elementary data of a field to produce one elementary data point.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
weightsname
(field)expected type(s)

Field containing weights, one weight per entity

pin 2optional
time_scopingname
(scoping)expected type(s)

time_scoping

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Field containing the (weighted) sum for each component in an elementary data

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: accumulate_fc
  • full name: math.accumulate_fc
  • internal name: accumulate_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.accumulate_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.weights.Connect(my_weights)
op.inputs.time_scoping.Connect(my_time_scoping)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.accumulate_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.weights.connect(my_weights)
op.inputs.time_scoping.connect(my_time_scoping)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("accumulate_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_weights);
op.connect(2, my_time_scoping);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: heat flux

Description

Read/compute heat flux by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot
  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: heat_flux
  • full name: result.heat_flux
  • internal name: TF
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.heat_flux() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.heat_flux() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("TF"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: co-energy

Description

Read/compute co-energy (magnetics) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • mapdl: rth,rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: co_energy
  • full name: result.co_energy
  • internal name: ENG_CO
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.co_energy() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.co_energy() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENG_CO"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: dot

Description

Computes a general notion of inner product between two fields of possibly different dimensionality.

Inputs

pin 0requested
fieldAname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

pin 1requested
fieldBname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: generalized_inner_product
  • full name: math.generalized_inner_product
  • internal name: generalized_inner_product
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.generalized_inner_product() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.generalized_inner_product() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("generalized_inner_product"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: outer product

Description

Computes the outer product of two vector fields.

Inputs

pin 0requested
fieldAname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

pin 1requested
fieldBname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: outer_product
  • full name: math.outer_product
  • internal name: outer_product
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.outer_product() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.outer_product() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("outer_product"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: overall dot

Description

Computes a dot product between two fields (fields are seen like a single large vector) and returns a scalar.

Inputs

pin 0requested
fieldAname
(field)expected type(s)
pin 1requested
fieldBname
(field)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Field defined on over-all location, contains a unique scalar value

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: overall_dot
  • full name: math.overall_dot
  • internal name: native::overall_dot
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.overall_dot() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.overall_dot() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("native::overall_dot"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: relative error

Description

Computes the relative error between a reference scalar field and another scalar field.

Inputs

pin 0requested
valuename
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

pin 1requested
referencename
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)
pin 1requested
zero_ref_scopingname
(scoping)expected type(s)

Ids of entities where reference value is zero.

pin 2requested
no_ref_scopingname
(scoping)expected type(s)

Ids of entities where there are no reference value.

Configurations

binary_operationThis option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
(binary_operation_enum | int32)expected type(s)
1default value
: This option allows to choose how two inputs will be treated together. eOnlyIntersection (0) means that the output will only contain the entities shared by all the inputs. eUnion (1) means that the output will contain all the entities contained in at least one of the inputs.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: math
  • plugin: core
  • scripting name: relative_error
  • full name: math.relative_error
  • internal name: relative_error
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.relative_error() # operator instantiation
op.inputs.value.Connect(my_value)
op.inputs.reference.Connect(my_reference)
my_field = op.outputs.field.GetData()
my_zero_ref_scoping = op.outputs.zero_ref_scoping.GetData()
my_no_ref_scoping = op.outputs.no_ref_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.relative_error() # operator instantiation
op.inputs.value.connect(my_value)
op.inputs.reference.connect(my_reference)
my_field = op.outputs.field()
my_zero_ref_scoping = op.outputs.zero_ref_scoping()
my_no_ref_scoping = op.outputs.no_ref_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("relative_error"); // operator instantiation
op.connect(0, my_value);
op.connect(1, my_reference);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Scoping my_zero_ref_scoping = op.getOutput<ansys::dpf::Scoping>(1);
ansys::dpf::Scoping my_no_ref_scoping = op.getOutput<ansys::dpf::Scoping>(2);

result: reaction force Y

Description

Read/compute nodal reaction forces Y component of the vector (2nd component) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: reaction_force_Y
  • full name: result.reaction_force_Y
  • internal name: RFY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.reaction_force_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.reaction_force_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("RFY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: velocity Y

Description

Read/compute nodal velocities Y component of the vector (2nd component) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: velocity_Y
  • full name: result.velocity_Y
  • internal name: VY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.velocity_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.velocity_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("VY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global velocity (LSDyna)

Description

Read Global Velocity (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout,d3plot

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_velocity
  • full name: result.global_velocity
  • internal name: GLOB_V
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_velocity() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_velocity() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_V"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: superficial velocity

Description

Read Superficial Velocity by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: superficial_velocity
  • full name: result.superficial_velocity
  • internal name: V_SUP
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.superficial_velocity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.superficial_velocity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("V_SUP"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: absolute value by component (field)

Description

Compute the absolute value of each data value of the input field, no norm performed.

Inputs

pin 0requested
fieldname
(field | fields_container | double | vector)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: absolute_value_by_component
  • full name: math.absolute_value_by_component
  • internal name: absolute_value_by_component
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.absolute_value_by_component() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.absolute_value_by_component() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("absolute_value_by_component"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: thermal strain

Description

Read/compute element nodal component thermal strains by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: thermal_strain
  • full name: result.thermal_strain
  • internal name: ETH
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thermal_strain() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thermal_strain() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ETH"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: incremental energy

Description

Read/compute incremental energy (magnetics) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • mapdl: rth,rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: incremental_energy
  • full name: result.incremental_energy
  • internal name: ENG_INC
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.incremental_energy() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.incremental_energy() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENG_INC"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: absolute value by component (fields container)

Description

Compute the absolute value of each data value of the input field, no norm performed.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: absolute_value_by_component_fc
  • full name: math.absolute_value_by_component_fc
  • internal name: absolute_value_by_component_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.absolute_value_by_component_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.absolute_value_by_component_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("absolute_value_by_component_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: stiffness matrix energy

Description

Read/compute element energy associated with the stiffness matrix by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • mapdl: mode,rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stiffness_matrix_energy
  • full name: result.stiffness_matrix_energy
  • internal name: ENG_SE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stiffness_matrix_energy() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stiffness_matrix_energy() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENG_SE"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: total temperature

Description

Read Total Temperature by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: total_temperature
  • full name: result.total_temperature
  • internal name: TEMP_TOT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.total_temperature() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.total_temperature() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("TEMP_TOT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

metadata: element types provider

Description

Reads element types data from the result files contained in the streams or data sources.

Supported file types

  • mapdl: rst,rth

Inputs

pin 1optional
solver_element_types_idsname
(int32 | vector)expected type(s)

Element Type ids to recover used by the solver. If not set, all available element types to be recovered.

pin 3optional
streamsname
(streams_container)expected type(s)

Result file container allowed to be kept open to cache data.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Result file path container, used if no streams are set.

Outputs

pin 0requested
element_types_dataname
(generic_data_container)expected type(s)

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.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: element_types_provider
  • full name: metadata.element_types_provider
  • internal name: element_types_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.element_types_provider() # operator instantiation
op.inputs.solver_element_types_ids.Connect(my_solver_element_types_ids)
op.inputs.streams.Connect(my_streams)
op.inputs.data_sources.Connect(my_data_sources)
my_element_types_data = op.outputs.element_types_data.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.element_types_provider() # operator instantiation
op.inputs.solver_element_types_ids.connect(my_solver_element_types_ids)
op.inputs.streams.connect(my_streams)
op.inputs.data_sources.connect(my_data_sources)
my_element_types_data = op.outputs.element_types_data()
#include "dpf_api.h"

ansys::dpf::Operator op("element_types_provider"); // operator instantiation
op.connect(1, my_solver_element_types_ids);
op.connect(3, my_streams);
op.connect(4, my_data_sources);
ansys::dpf::GenericDataContainer my_element_types_data = op.getOutput<ansys::dpf::GenericDataContainer>(0);

utility: delegate to operator

Description

Delegate the run to an Operator instantiated by the name in input (forwards all the input of this Operator to the sub Operator).

Inputs

pin -1requested
operator_namename
(string)expected type(s)

Outputs

pin 0, 1...requested, ellipsis
anyname
(any)expected type(s)

inputs

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: delegate_to_operator
  • full name: utility.delegate_to_operator
  • internal name: delegate_to_operator
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.delegate_to_operator() # operator instantiation
op.inputs.operator_name.Connect(my_operator_name)
my_any = op.outputs.any.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.delegate_to_operator() # operator instantiation
op.inputs.operator_name.connect(my_operator_name)
my_any = op.outputs.any()
#include "dpf_api.h"

ansys::dpf::Operator op("delegate_to_operator"); // operator instantiation
op.connect(-1, my_operator_name);
ansys::dpf::Any my_any = op.getOutput<ansys::dpf::Any>(0);

result: acceleration Y

Description

Read/compute nodal accelerations Y component of the vector (2nd component) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: acceleration_Y
  • full name: result.acceleration_Y
  • internal name: AY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.acceleration_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.acceleration_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("AY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

logic: component selector (fields container)

Description

Creates a scalar fields container based on the selected component for each field.

Inputs

pin 0requested
fields_containername
(fields_container | field)expected type(s)
pin 1requested
component_numbername
(int32 | vector)expected type(s)

one or several component index that will be extracted from the initial field.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: component_selector_fc
  • full name: logic.component_selector_fc
  • internal name: component_selector_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.component_selector_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.component_number.Connect(my_component_number)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.component_selector_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.component_number.connect(my_component_number)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("component_selector_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_component_number);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

logic: component selector (field)

Description

Creates a scalar/vector field based on the selected component.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)
pin 1requested
component_numbername
(int32 | vector)expected type(s)

One or several component index that will be extracted from the initial field.

pin 2optional
default_valuename
(double)expected type(s)

Set a default value for components that do not exist.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: component_selector
  • full name: logic.component_selector
  • internal name: component_selector
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.component_selector() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.component_number.Connect(my_component_number)
op.inputs.default_value.Connect(my_default_value)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.component_selector() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.component_number.connect(my_component_number)
op.inputs.default_value.connect(my_default_value)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("component_selector"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_component_number);
op.connect(2, my_default_value);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

scoping: on property

Description

Provides a scoping at a given location based on a given property name and a property number.

Inputs

pin 0requested
requested_locationname
(string)expected type(s)

Nodal or Elemental location are expected

pin 1requested
property_namename
(string)expected type(s)

ex "mapdl_element_type", "mapdl_element_type_id", "apdl_type_index", "mapdl_type_id", "material", "apdl_section_id", "apdl_real_id", "apdl_esys_id", "shell_axi", "volume_axi"...

pin 2requested
property_idname
(int32)expected type(s)
pin 3optional
streams_containername
(streams_container)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)
pin 5optional
inclusivename
(int32)expected type(s)

If element scoping is requested on a nodal named selection, if inclusive == 1 then all the elements/faces adjacent to the nodes/faces ids in input are added, if inclusive == 0, only the elements/faces which have all their nodes/faces in the scoping are included

Outputs

pin 0requested
mesh_scopingname
(scoping)expected type(s)

Scoping

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: on_property
  • full name: scoping.on_property
  • internal name: scoping_provider_by_prop
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.on_property() # operator instantiation
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.property_name.Connect(my_property_name)
op.inputs.property_id.Connect(my_property_id)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.inclusive.Connect(my_inclusive)
my_mesh_scoping = op.outputs.mesh_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.on_property() # operator instantiation
op.inputs.requested_location.connect(my_requested_location)
op.inputs.property_name.connect(my_property_name)
op.inputs.property_id.connect(my_property_id)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.inclusive.connect(my_inclusive)
my_mesh_scoping = op.outputs.mesh_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("scoping_provider_by_prop"); // operator instantiation
op.connect(0, my_requested_location);
op.connect(1, my_property_name);
op.connect(2, my_property_id);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_inclusive);
ansys::dpf::Scoping my_mesh_scoping = op.getOutput<ansys::dpf::Scoping>(0);

result: stress intensity

Description

Reads/computes element nodal component stresses, average it on nodes (by default) and computes its invariants.

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress_intensity
  • full name: result.stress_intensity
  • internal name: S_intensity
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_intensity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_intensity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("S_intensity"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

logic: component transformer (field)

Description

Takes the input field and creates a field with overriden value on given components.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)
pin 1requested
component_numbername
(int32 | vector)expected type(s)

One or several component index that will be modified from the initial field.

pin 2optional
default_valuename
(double)expected type(s)

Set a default value for components selected.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: component_transformer
  • full name: logic.component_transformer
  • internal name: component_transformer
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.component_transformer() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.component_number.Connect(my_component_number)
op.inputs.default_value.Connect(my_default_value)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.component_transformer() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.component_number.connect(my_component_number)
op.inputs.default_value.connect(my_default_value)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("component_transformer"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_component_number);
op.connect(2, my_default_value);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

logic: component transformer (fields container)

Description

Takes the input field and creates a field with overriden value on given components.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
component_numbername
(int32 | vector)expected type(s)

One or several component index that will be modified from the initial field.

pin 2optional
default_valuename
(double)expected type(s)

Set a default value for components selected.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: component_transformer_fc
  • full name: logic.component_transformer_fc
  • internal name: component_transformer_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.component_transformer_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.component_number.Connect(my_component_number)
op.inputs.default_value.Connect(my_default_value)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.component_transformer_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.component_number.connect(my_component_number)
op.inputs.default_value.connect(my_default_value)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("component_transformer_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_component_number);
op.connect(2, my_default_value);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

logic: same property fields?

Description

Takes two property fields and compares them.

Inputs

pin 0requested
property_fieldAname
(abstract_meshed_region)expected type(s)
pin 1requested
property_fieldBname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
are_identicalname
(bool)expected type(s)
pin 1requested
informationname
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: identical_property_fields
  • full name: logic.identical_property_fields
  • internal name: compare::property_field
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.identical_property_fields() # operator instantiation
op.inputs.property_fieldA.Connect(my_property_fieldA)
op.inputs.property_fieldB.Connect(my_property_fieldB)
my_are_identical = op.outputs.are_identical.GetData()
my_information = op.outputs.information.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.identical_property_fields() # operator instantiation
op.inputs.property_fieldA.connect(my_property_fieldA)
op.inputs.property_fieldB.connect(my_property_fieldB)
my_are_identical = op.outputs.are_identical()
my_information = op.outputs.information()
#include "dpf_api.h"

ansys::dpf::Operator op("compare::property_field"); // operator instantiation
op.connect(0, my_property_fieldA);
op.connect(1, my_property_fieldB);
bool my_are_identical = op.getOutput<bool>(0);
std::string my_information = op.getOutput<std::string>(1);

logic: elementary data selector (fields container)

Description

Creates a scalar fields container based on the selected elementary data for each field.

Inputs

pin 0requested
fields_containername
(fields_container | field)expected type(s)
pin 1requested
elementary_data_indexname
(int32 | vector)expected type(s)

one or several elementary data indices that will be extracted from the initial field. For a field with a nature matrix, this extracts the line indices.

pin 3optional
elementary_data_index_2name
(int32 | vector)expected type(s)

For a field with nature matrix, this extracts the column indices.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: elementary_data_selector_fc
  • full name: logic.elementary_data_selector_fc
  • internal name: elementary_data_selector_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.elementary_data_selector_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.elementary_data_index.Connect(my_elementary_data_index)
op.inputs.elementary_data_index_2.Connect(my_elementary_data_index_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.elementary_data_selector_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.elementary_data_index.connect(my_elementary_data_index)
op.inputs.elementary_data_index_2.connect(my_elementary_data_index_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("elementary_data_selector_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_elementary_data_index);
op.connect(3, my_elementary_data_index_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: convert to scoping

Description

take a int or a vector of int and transform it in a one entity field of location "numeric".

Inputs

pin 0requested
int_or_vector_intname
(int32 | vector)expected type(s)

int or vector of int

pin 1optional
locationname
(string)expected type(s)

Outputs

pin 0requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: ints_to_scoping
  • full name: utility.ints_to_scoping
  • internal name: scopingify
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.ints_to_scoping() # operator instantiation
op.inputs.int_or_vector_int.Connect(my_int_or_vector_int)
op.inputs.location.Connect(my_location)
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.ints_to_scoping() # operator instantiation
op.inputs.int_or_vector_int.connect(my_int_or_vector_int)
op.inputs.location.connect(my_location)
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("scopingify"); // operator instantiation
op.connect(0, my_int_or_vector_int);
op.connect(1, my_location);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(0);

logic: elementary data selector (field)

Description

Creates a scalar/vector field based on the selected elementary data.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)
pin 1requested
elementary_data_indexname
(int32 | vector)expected type(s)

One or several elementary data index that will be extracted from the initial field. For field with nature matrix, this is the line indices to extract.

pin 2optional
default_valuename
(double)expected type(s)

Set a default value for elementary data that do not exist.

pin 3optional
elementary_data_index_2name
(int32 | vector)expected type(s)

For field with nature matrix, this is the column indices to extract.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: elementary_data_selector
  • full name: logic.elementary_data_selector
  • internal name: elementary_data_selector
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.elementary_data_selector() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.elementary_data_index.Connect(my_elementary_data_index)
op.inputs.default_value.Connect(my_default_value)
op.inputs.elementary_data_index_2.Connect(my_elementary_data_index_2)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.elementary_data_selector() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.elementary_data_index.connect(my_elementary_data_index)
op.inputs.default_value.connect(my_default_value)
op.inputs.elementary_data_index_2.connect(my_elementary_data_index_2)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("elementary_data_selector"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_elementary_data_index);
op.connect(2, my_default_value);
op.connect(3, my_elementary_data_index_2);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: change location

Description

change the location of a field.

Inputs

pin 0requested
fieldname
(field)expected type(s)
pin 1requested
new_locationname
(string)expected type(s)

new location of the output field ex 'Nodal', 'ElementalNodal', 'Elemental'...

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: change_location
  • full name: utility.change_location
  • internal name: change_location
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.change_location() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.new_location.Connect(my_new_location)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.change_location() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.new_location.connect(my_new_location)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("change_location"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_new_location);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: extract field

Description

Extracts the fields at the indices defined in the vector (in 1) from the fields container (in 0).

Inputs

pin 0requested
fields_containername
(field | fields_container)expected type(s)

if a field is in input, it is passed on as an output

pin 1optional
indicesname
(vector)expected type(s)

Default is the first field

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: extract_field
  • full name: utility.extract_field
  • internal name: ExtractFromFC
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.extract_field() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.indices.Connect(my_indices)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.extract_field() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.indices.connect(my_indices)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("ExtractFromFC"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_indices);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

mesh: node coordinates

Description

Returns the node coordinates of the mesh(es) in input.

Inputs

pin 7requested
meshname
(abstract_meshed_region | meshes_container)expected type(s)

Outputs

pin 0requested
coordinatesname
(field | fields_container)expected type(s)

if the input is a meshed region, a field of coordinates is the output, else if the input is a meshes container, a fields container (one field by mesh) is the output

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: node_coordinates
  • full name: mesh.node_coordinates
  • internal name: mesh::node_coordinates
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.node_coordinates() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
my_coordinates = op.outputs.coordinates.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.node_coordinates() # operator instantiation
op.inputs.mesh.connect(my_mesh)
my_coordinates = op.outputs.coordinates()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh::node_coordinates"); // operator instantiation
op.connect(7, my_mesh);
ansys::dpf::Field my_coordinates = op.getOutput<ansys::dpf::Field>(0);

mesh: stl export

Description

export a mesh into a stl file.

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)
pin 1requested
file_pathname
(string)expected type(s)

Outputs

pin 0requested
data_sourcesname
(data_sources)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: stl_export
  • full name: mesh.stl_export
  • internal name: stl_export
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.stl_export() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
op.inputs.file_path.Connect(my_file_path)
my_data_sources = op.outputs.data_sources.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.stl_export() # operator instantiation
op.inputs.mesh.connect(my_mesh)
op.inputs.file_path.connect(my_file_path)
my_data_sources = op.outputs.data_sources()
#include "dpf_api.h"

ansys::dpf::Operator op("stl_export"); // operator instantiation
op.connect(0, my_mesh);
op.connect(1, my_file_path);
ansys::dpf::DataSources my_data_sources = op.getOutput<ansys::dpf::DataSources>(0);

utility: bind support

Description

Ties a support to a field.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
supportname
(abstract_meshed_region | abstract_field_support)expected type(s)

meshed region or a support of the field

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: bind_support
  • full name: utility.bind_support
  • internal name: BindSupport
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.bind_support() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.support.Connect(my_support)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.bind_support() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.support.connect(my_support)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("BindSupport"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_support);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: convert to meshes container

Description

Creates a meshes container containing the mesh provided on pin 0.

Inputs

pin 0requested
meshname
(abstract_meshed_region | meshes_container)expected type(s)

If a meshes container is set in input, it is passed on as an output with the additional label space (if any).

pin 1requested
labelname
(label_space)expected type(s)

Sets a label space.

Outputs

pin 0requested
meshes_containername
(meshes_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: mesh_to_mc
  • full name: utility.mesh_to_mc
  • internal name: InjectToMeshesContainer
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.mesh_to_mc() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
op.inputs.label.Connect(my_label)
my_meshes_container = op.outputs.meshes_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.mesh_to_mc() # operator instantiation
op.inputs.mesh.connect(my_mesh)
op.inputs.label.connect(my_label)
my_meshes_container = op.outputs.meshes_container()
#include "dpf_api.h"

ansys::dpf::Operator op("InjectToMeshesContainer"); // operator instantiation
op.connect(0, my_mesh);
op.connect(1, my_label);
ansys::dpf::MeshesContainer my_meshes_container = op.getOutput<ansys::dpf::MeshesContainer>(0);

result: equivalent stress parameter

Description

Read/compute element nodal equivalent stress parameter by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: eqv_stress_parameter
  • full name: result.eqv_stress_parameter
  • internal name: ENL_SEPL
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.eqv_stress_parameter() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.eqv_stress_parameter() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENL_SEPL"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: beam torsional moment (LSDyna)

Description

Read Beam Torsional Moment (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: beam_torsional_moment
  • full name: result.beam_torsional_moment
  • internal name: B_MT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.beam_torsional_moment() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.beam_torsional_moment() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("B_MT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: convert to field

Description

Create scalar or vector Field.

Inputs

pin 0optional
double_or_vector_doublename
(double | vector)expected type(s)

Data of the field, default is 0-field. Specify a double to have a field of same value or specify directly the data vector.

pin 1optional
unitname
(string)expected type(s)

Unit symbol (m, Hz, kg, ...)

pin 2optional
locationname
(string)expected type(s)

Location of the field ex 'Nodal', 'ElementalNodal', 'Elemental'... Default is 'numeric'.

pin 3optional
num_entityname
(int32)expected type(s)

Number of field entities. Default is 1 or the size of the scoping in input if specified.

pin 4optional
num_compname
(int32)expected type(s)

Number of field components. Default is 1.

pin 5optional
scopingname
(scoping)expected type(s)

Scoping.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: scalars_to_field
  • full name: utility.scalars_to_field
  • internal name: fieldify
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.scalars_to_field() # operator instantiation
op.inputs.double_or_vector_double.Connect(my_double_or_vector_double)
op.inputs.unit.Connect(my_unit)
op.inputs.location.Connect(my_location)
op.inputs.num_entity.Connect(my_num_entity)
op.inputs.num_comp.Connect(my_num_comp)
op.inputs.scoping.Connect(my_scoping)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.scalars_to_field() # operator instantiation
op.inputs.double_or_vector_double.connect(my_double_or_vector_double)
op.inputs.unit.connect(my_unit)
op.inputs.location.connect(my_location)
op.inputs.num_entity.connect(my_num_entity)
op.inputs.num_comp.connect(my_num_comp)
op.inputs.scoping.connect(my_scoping)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("fieldify"); // operator instantiation
op.connect(0, my_double_or_vector_double);
op.connect(1, my_unit);
op.connect(2, my_location);
op.connect(3, my_num_entity);
op.connect(4, my_num_comp);
op.connect(5, my_scoping);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: beam axial total strain (LSDyna)

Description

Read Beam Axial Total strain (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
integration_pointname
(int32)expected type(s)

integration point where the result will be read from. Default value: 0 (first integration point).

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: beam_axial_total_strain
  • full name: result.beam_axial_total_strain
  • internal name: B_EL
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.beam_axial_total_strain() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.integration_point.Connect(my_integration_point)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.beam_axial_total_strain() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.integration_point.connect(my_integration_point)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("B_EL"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_integration_point);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: set property

Description

Sets a property to an input field/field container.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)
pin 1requested
property_namename
(string)expected type(s)

Property to set

pin 2requested
property_valuename
(string | int32 | double)expected type(s)

Property to set

Outputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: set_property
  • full name: utility.set_property
  • internal name: field::set_property
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.set_property() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.property_name.Connect(my_property_name)
op.inputs.property_value.Connect(my_property_value)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.set_property() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.property_name.connect(my_property_name)
op.inputs.property_value.connect(my_property_value)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("field::set_property"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_property_name);
op.connect(2, my_property_value);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: electric flux density Y

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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: electric_flux_density_Y
  • full name: result.electric_flux_density_Y
  • internal name: EFDY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.electric_flux_density_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.electric_flux_density_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EFDY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: forward field

Description

Returns the input field or fields container.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: forward_field
  • full name: utility.forward_field
  • internal name: forward_field
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.forward_field() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.forward_field() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("forward_field"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: forward fields container

Description

Returns the input field or fields container.

Inputs

pin 0requested
fieldsname
(fields_container | field)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: forward_fields_container
  • full name: utility.forward_fields_container
  • internal name: forward_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.forward_fields_container() # operator instantiation
op.inputs.fields.Connect(my_fields)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.forward_fields_container() # operator instantiation
op.inputs.fields.connect(my_fields)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("forward_fc"); // operator instantiation
op.connect(0, my_fields);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: electric flux density

Description

Read/compute Electric flux density by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: electric_flux_density
  • full name: result.electric_flux_density
  • internal name: EFD
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.electric_flux_density() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.electric_flux_density() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EFD"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: plastic strain principal 2

Description

Read/compute element nodal component plastic strains 2nd principal component by calling the readers defined by the datasources and computing its eigen values. The off-diagonal strains are first converted from Voigt notation to the standard strain values.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain_principal_2
  • full name: result.plastic_strain_principal_2
  • internal name: EPPL2
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_principal_2() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_principal_2() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPPL2"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: forward meshes container

Description

Returns the input mesh or meshes container into a meshes container.

Inputs

pin 0requested
meshesname
(meshes_container | abstract_meshed_region)expected type(s)
pin 1optional
default_labelname
(string)expected type(s)

this default label is used if a new meshes container needs to be created (default is unknown)

Outputs

pin 0requested
meshes_containername
(meshes_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: forward_meshes_container
  • full name: utility.forward_meshes_container
  • internal name: forward_meshes_container
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.forward_meshes_container() # operator instantiation
op.inputs.meshes.Connect(my_meshes)
op.inputs.default_label.Connect(my_default_label)
my_meshes_container = op.outputs.meshes_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.forward_meshes_container() # operator instantiation
op.inputs.meshes.connect(my_meshes)
op.inputs.default_label.connect(my_default_label)
my_meshes_container = op.outputs.meshes_container()
#include "dpf_api.h"

ansys::dpf::Operator op("forward_meshes_container"); // operator instantiation
op.connect(0, my_meshes);
op.connect(1, my_default_label);
ansys::dpf::MeshesContainer my_meshes_container = op.getOutput<ansys::dpf::MeshesContainer>(0);

geo: integrate over elements

Description

Integration of an input field over mesh.

Inputs

pin 0requested
fieldname
(field)expected type(s)
pin 1optional
scopingname
(scoping)expected type(s)

Integrate the input field over a specific scoping.

pin 2optional
meshname
(abstract_meshed_region)expected type(s)

Mesh to integrate on. If not provided, the one from input field is employed.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: geo
  • plugin: core
  • scripting name: integrate_over_elements
  • full name: geo.integrate_over_elements
  • internal name: element::integrate
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.integrate_over_elements() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.scoping.Connect(my_scoping)
op.inputs.mesh.Connect(my_mesh)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.integrate_over_elements() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.scoping.connect(my_scoping)
op.inputs.mesh.connect(my_mesh)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("element::integrate"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_scoping);
op.connect(2, my_mesh);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: forward

Description

Return all the inputs as outputs.

Inputs

pin 0requested
anyname
(any)expected type(s)

any type of input

Outputs

pin 0requested
anyname
(any)expected type(s)

same types as inputs

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
read_inputs_in_parallelIf this option is set to true, the operator's inputs will be evaluated in parallel.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the operator's inputs will be evaluated in parallel.

Scripting

  • category: utility
  • plugin: core
  • scripting name: forward
  • full name: utility.forward
  • internal name: forward
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.forward() # operator instantiation
op.inputs.any.Connect(my_any)
my_any = op.outputs.any.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.forward() # operator instantiation
op.inputs.any.connect(my_any)
my_any = op.outputs.any()
#include "dpf_api.h"

ansys::dpf::Operator op("forward"); // operator instantiation
op.connect(0, my_any);
ansys::dpf::Any my_any = op.getOutput<ansys::dpf::Any>(0);

result: compute total strain X

Description

Computes the strain from a displacement field. Only SOLID185 (B-Bar, Simplified Enhanced Strain, Enhanced Strain formulations), SOLID186 (Full Integration) & SOLID187 elements are supported. Layered elements are not supported. Thermal strains are not supported. Only one value of material properties are allowed per element for isotropic and orthotropic elasticity. Material nonlinearity is not supported 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 XX normal component (00 component).

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.. Will only be used if no displacement input is given (will be applied on displacement operator).

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Optional if a mesh or a data_sources have been connected. Required if no displacement input have been connected.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Optional if a mesh or a streams_container have been connected, or if the displacement's field has a mesh support. Required if no displacement input have been connected.

pin 5optional
extrapolatename
(int32)expected type(s)

Whether to extrapolate the data from the integration points to the nodes.

pin 6optional
nonlinearname
(int32)expected type(s)

Whether to use nonlinear geometry or nonlinear material (1 = large strain, 2 = hyperelasticity).

pin 7optional
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

The underlying mesh. Optional if a data_sources or a streams_container have been connected, or if the displacement's field has a mesh support.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10optional
displacementname
(fields_container | field)expected type(s)

Field/or fields container containing only the displacement field (nodal). If none specified, read displacements from result file using the data_sources.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_total_strain_X
  • full name: result.compute_total_strain_X
  • internal name: compute_total_strain_X
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_total_strain_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.extrapolate.Connect(my_extrapolate)
op.inputs.nonlinear.Connect(my_nonlinear)
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.displacement.Connect(my_displacement)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_total_strain_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.extrapolate.connect(my_extrapolate)
op.inputs.nonlinear.connect(my_nonlinear)
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.displacement.connect(my_displacement)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_total_strain_X"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_extrapolate);
op.connect(6, my_nonlinear);
op.connect(7, my_abstract_meshed_region);
op.connect(9, my_requested_location);
op.connect(10, my_displacement);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: plastic strain eqv

Description

Read/compute element nodal equivalent plastic strain by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain_eqv
  • full name: result.plastic_strain_eqv
  • internal name: EPPL_EQV
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_eqv() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_eqv() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPPL_EQV"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: gasket inelastic closure XY

Description

Read/compute elemental gasket inelastic closure XY shear component (01 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_inelastic_closure_XY
  • full name: result.gasket_inelastic_closure_XY
  • internal name: GKDIXY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_inelastic_closure_XY() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_inelastic_closure_XY() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKDIXY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: incremental meshes container

Description

Incrementaly merge the input.

Inputs

pin 0requested
inputname
(meshes_container)expected type(s)

Outputs

pin 0requested
incremented_resultname

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: meshes_container
  • full name: utility.meshes_container
  • internal name: incremental::merge::meshes_container
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.meshes_container() # operator instantiation
op.inputs.input.Connect(my_input)
my_incremented_result = op.outputs.incremented_result.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.meshes_container() # operator instantiation
op.inputs.input.connect(my_input)
my_incremented_result = op.outputs.incremented_result()
#include "dpf_api.h"

ansys::dpf::Operator op("incremental::merge::meshes_container"); // operator instantiation
op.connect(0, my_input);
ansys::dpf::Any my_incremented_result = op.getOutput<ansys::dpf::Any>(0);

utility: txt file to dpf

Description

Take an input string and parse it into dataProcessing type

Inputs

pin 0requested
input_stringname
(string)expected type(s)

ex: 'double:1.0', 'int:1', 'vector:1.0;1.0'

Outputs

pin 0, 1...requested, ellipsis
any_outputname

any output

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: txt_file_to_dpf
  • full name: utility.txt_file_to_dpf
  • internal name: text_parser
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.txt_file_to_dpf() # operator instantiation
op.inputs.input_string.Connect(my_input_string)
my_any_output = op.outputs.any_output.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.txt_file_to_dpf() # operator instantiation
op.inputs.input_string.connect(my_input_string)
my_any_output = op.outputs.any_output()
#include "dpf_api.h"

ansys::dpf::Operator op("text_parser"); // operator instantiation
op.connect(0, my_input_string);

utility: bind support (fields container)

Description

Ties a support to a fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
supportname
(abstract_meshed_region | abstract_field_support | time_freq_support)expected type(s)

Meshed region or a support of the field.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: bind_support_fc
  • full name: utility.bind_support_fc
  • internal name: BindSupportFC
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.bind_support_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.support.Connect(my_support)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.bind_support_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.support.connect(my_support)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("BindSupportFC"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_support);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: creep strain eqv

Description

Read/compute element nodal equivalent component creep strains by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain_eqv
  • full name: result.creep_strain_eqv
  • internal name: EPCR_EQV
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain_eqv() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain_eqv() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPCR_EQV"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: normal contact moment

Description

Read/compute normal contact moment by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: normal_contact_moment
  • full name: result.normal_contact_moment
  • internal name: CFTNOR
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.normal_contact_moment() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.normal_contact_moment() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("CFTNOR"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: fields container get attribute

Description

Uses the FieldsContainer APIs to return a given attribute of the fields container in input.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
property_namename
(string)expected type(s)

Supported property names are: "label_scoping", "label_values", "time_freq_support", "labels", "field_scoping" and "field".

pin 2optional
property_identifiername
(string | int32)expected type(s)

Additional pin for some property : the label name for "label_scoping" or "label_values", the field index (default 0) for "field_scoping" or "field".

Outputs

pin 0requested
propertyname
(scoping | vector | time_freq_support | vector | label_space | field)expected type(s)

Returns a Scoping for property: "label_scoping", a vector of int for "label_values", a time freq support for "time_freq_support", a vector of string for "labels", a LabelSpace for "field_scoping" and a "field" for "field".

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: fc_get_attribute
  • full name: utility.fc_get_attribute
  • internal name: fieldscontainer::get_attribute
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.fc_get_attribute() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.property_name.Connect(my_property_name)
op.inputs.property_identifier.Connect(my_property_identifier)
my_property = op.outputs.property.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.fc_get_attribute() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.property_name.connect(my_property_name)
op.inputs.property_identifier.connect(my_property_identifier)
my_property = op.outputs.property()
#include "dpf_api.h"

ansys::dpf::Operator op("fieldscontainer::get_attribute"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_property_name);
op.connect(2, my_property_identifier);
ansys::dpf::Scoping my_property = op.getOutput<ansys::dpf::Scoping>(0);

result: thermal strain XZ

Description

Read/compute element nodal component thermal strains XZ shear component (02 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: thermal_strain_XZ
  • full name: result.thermal_strain_XZ
  • internal name: ETHXZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thermal_strain_XZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thermal_strain_XZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ETHXZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: assemble scalars to vector

Description

Takes three scalar fields and assembles them as a 3D vector field.

Inputs

pin 0optional
xname
(field)expected type(s)
pin 1optional
yname
(field)expected type(s)
pin 2optional
zname
(field)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: assemble_scalars_to_vectors
  • full name: utility.assemble_scalars_to_vectors
  • internal name: assemble_scalars_to_vectors
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.assemble_scalars_to_vectors() # operator instantiation
op.inputs.x.Connect(my_x)
op.inputs.y.Connect(my_y)
op.inputs.z.Connect(my_z)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.assemble_scalars_to_vectors() # operator instantiation
op.inputs.x.connect(my_x)
op.inputs.y.connect(my_y)
op.inputs.z.connect(my_z)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("assemble_scalars_to_vectors"); // operator instantiation
op.connect(0, my_x);
op.connect(1, my_y);
op.connect(2, my_z);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: global eroded hourglass energy (LSDyna)

Description

Read Global Eroded Hourglass Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_eroded_hourglass_energy
  • full name: result.global_eroded_hourglass_energy
  • internal name: GLOB_ENG_ERAHO
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_eroded_hourglass_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_eroded_hourglass_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_ENG_ERAHO"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: assemble scalars to vector fc

Description

Takes three scalar fields container and assembles them as a 3D vector fields container.

Inputs

pin 0optional
xname
(fields_container)expected type(s)
pin 1optional
yname
(fields_container)expected type(s)
pin 2optional
zname
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: assemble_scalars_to_vectors_fc
  • full name: utility.assemble_scalars_to_vectors_fc
  • internal name: assemble_scalars_to_vectors_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.assemble_scalars_to_vectors_fc() # operator instantiation
op.inputs.x.Connect(my_x)
op.inputs.y.Connect(my_y)
op.inputs.z.Connect(my_z)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.assemble_scalars_to_vectors_fc() # operator instantiation
op.inputs.x.connect(my_x)
op.inputs.y.connect(my_y)
op.inputs.z.connect(my_z)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("assemble_scalars_to_vectors_fc"); // operator instantiation
op.connect(0, my_x);
op.connect(1, my_y);
op.connect(2, my_z);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

mesh: from scopings

Description

Extracts multiple meshed region base on a scoping and saved in a MeshesContainer

Inputs

pin 1requested
scopings_containername
(scopings_container)expected type(s)

if nodal scoping, then the scoping is transposed respecting the inclusive pin

pin 2optional
inclusivename
(int32)expected type(s)

if inclusive == 1 then all the elements/faces adjacent to the nodes/faces ids in input are added, if inclusive == 0, only the elements/faces which have all their nodes/faces in the scoping are included

pin 3optional
nodes_onlyname
(bool)expected type(s)

returns mesh with nodes only (without any elements). Default is false.

pin 7requested
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
meshesname
(meshes_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: from_scopings
  • full name: mesh.from_scopings
  • internal name: meshes::by_scopings
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.from_scopings() # operator instantiation
op.inputs.scopings_container.Connect(my_scopings_container)
op.inputs.inclusive.Connect(my_inclusive)
op.inputs.nodes_only.Connect(my_nodes_only)
op.inputs.mesh.Connect(my_mesh)
my_meshes = op.outputs.meshes.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.from_scopings() # operator instantiation
op.inputs.scopings_container.connect(my_scopings_container)
op.inputs.inclusive.connect(my_inclusive)
op.inputs.nodes_only.connect(my_nodes_only)
op.inputs.mesh.connect(my_mesh)
my_meshes = op.outputs.meshes()
#include "dpf_api.h"

ansys::dpf::Operator op("meshes::by_scopings"); // operator instantiation
op.connect(1, my_scopings_container);
op.connect(2, my_inclusive);
op.connect(3, my_nodes_only);
op.connect(7, my_mesh);
ansys::dpf::MeshesContainer my_meshes = op.getOutput<ansys::dpf::MeshesContainer>(0);

math: make one on component

Description

Takes the input field's scoping and creates a field full of zeros, except for the indexes from pin 1 that will hold 1.0.

Inputs

pin 0requested
fieldAname
(field)expected type(s)
pin 1requested
scalar_intname
(int32)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: make_one_on_comp
  • full name: math.make_one_on_comp
  • internal name: make_one_on_comp
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.make_one_on_comp() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.scalar_int.Connect(my_scalar_int)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.make_one_on_comp() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.scalar_int.connect(my_scalar_int)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("make_one_on_comp"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_scalar_int);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: assemble scalars to matrix

Description

Take nine scalar fields and assemble them as a 3x3 matrix field. If the 'symmetrical' input is set to true, only six scalar fields are required (xx, yy, zz, xy, xz and yz).

Inputs

pin 0optional
xxname
(field)expected type(s)
pin 1optional
yyname
(field)expected type(s)
pin 2optional
zzname
(field)expected type(s)
pin 3optional
xyname
(field)expected type(s)
pin 4optional
yzname
(field)expected type(s)
pin 5optional
xzname
(field)expected type(s)
pin 6optional
yxname
(field)expected type(s)
pin 7optional
zyname
(field)expected type(s)
pin 8optional
zxname
(field)expected type(s)
pin 60optional
symmetricalname
(bool)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: assemble_scalars_to_matrices
  • full name: utility.assemble_scalars_to_matrices
  • internal name: assemble_scalars_to_matrices
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.assemble_scalars_to_matrices() # operator instantiation
op.inputs.xx.Connect(my_xx)
op.inputs.yy.Connect(my_yy)
op.inputs.zz.Connect(my_zz)
op.inputs.xy.Connect(my_xy)
op.inputs.yz.Connect(my_yz)
op.inputs.xz.Connect(my_xz)
op.inputs.yx.Connect(my_yx)
op.inputs.zy.Connect(my_zy)
op.inputs.zx.Connect(my_zx)
op.inputs.symmetrical.Connect(my_symmetrical)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.assemble_scalars_to_matrices() # operator instantiation
op.inputs.xx.connect(my_xx)
op.inputs.yy.connect(my_yy)
op.inputs.zz.connect(my_zz)
op.inputs.xy.connect(my_xy)
op.inputs.yz.connect(my_yz)
op.inputs.xz.connect(my_xz)
op.inputs.yx.connect(my_yx)
op.inputs.zy.connect(my_zy)
op.inputs.zx.connect(my_zx)
op.inputs.symmetrical.connect(my_symmetrical)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("assemble_scalars_to_matrices"); // operator instantiation
op.connect(0, my_xx);
op.connect(1, my_yy);
op.connect(2, my_zz);
op.connect(3, my_xy);
op.connect(4, my_yz);
op.connect(5, my_xz);
op.connect(6, my_yx);
op.connect(7, my_zy);
op.connect(8, my_zx);
op.connect(60, my_symmetrical);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: assemble scalars to matrix fc

Description

Take nine scalar fields container and assemble them as a 3x3 matrix fields. If the 'symmetrical' input is set to true, only six field containers are required (xx, yy, zz, xy, xz and yz).

Inputs

pin 0optional
xxname
(fields_container)expected type(s)
pin 1optional
yyname
(fields_container)expected type(s)
pin 2optional
zzname
(fields_container)expected type(s)
pin 3optional
xyname
(fields_container)expected type(s)
pin 4optional
yzname
(fields_container)expected type(s)
pin 5optional
xzname
(fields_container)expected type(s)
pin 6optional
yxname
(fields_container)expected type(s)
pin 7optional
zyname
(fields_container)expected type(s)
pin 8optional
zxname
(fields_container)expected type(s)
pin 60optional
symmetricalname
(bool)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: assemble_scalars_to_matrices_fc
  • full name: utility.assemble_scalars_to_matrices_fc
  • internal name: assemble_scalars_to_matrices_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.assemble_scalars_to_matrices_fc() # operator instantiation
op.inputs.xx.Connect(my_xx)
op.inputs.yy.Connect(my_yy)
op.inputs.zz.Connect(my_zz)
op.inputs.xy.Connect(my_xy)
op.inputs.yz.Connect(my_yz)
op.inputs.xz.Connect(my_xz)
op.inputs.yx.Connect(my_yx)
op.inputs.zy.Connect(my_zy)
op.inputs.zx.Connect(my_zx)
op.inputs.symmetrical.Connect(my_symmetrical)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.assemble_scalars_to_matrices_fc() # operator instantiation
op.inputs.xx.connect(my_xx)
op.inputs.yy.connect(my_yy)
op.inputs.zz.connect(my_zz)
op.inputs.xy.connect(my_xy)
op.inputs.yz.connect(my_yz)
op.inputs.xz.connect(my_xz)
op.inputs.yx.connect(my_yx)
op.inputs.zy.connect(my_zy)
op.inputs.zx.connect(my_zx)
op.inputs.symmetrical.connect(my_symmetrical)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("assemble_scalars_to_matrices_fc"); // operator instantiation
op.connect(0, my_xx);
op.connect(1, my_yy);
op.connect(2, my_zz);
op.connect(3, my_xy);
op.connect(4, my_yz);
op.connect(5, my_xz);
op.connect(6, my_yx);
op.connect(7, my_zy);
op.connect(8, my_zx);
op.connect(60, my_symmetrical);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: interface contact area (LSDyna)

Description

Read Interface Contact Area (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
entity_scopingname
(scoping)expected type(s)

entity (part for matsum, interface for rcforc) where the result will be scoped

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: interface_contact_area
  • full name: result.interface_contact_area
  • internal name: R_CA
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.interface_contact_area() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.entity_scoping.Connect(my_entity_scoping)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.interface_contact_area() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.entity_scoping.connect(my_entity_scoping)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("R_CA"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_entity_scoping);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

mesh: extract from field

Description

Returns the meshed region contained in the support of the mesh.

Inputs

pin 0requested
fieldname
(field)expected type(s)

Outputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: from_field
  • full name: mesh.from_field
  • internal name: GetSupportFromField
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.from_field() # operator instantiation
op.inputs.field.Connect(my_field)
my_mesh = op.outputs.mesh.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.from_field() # operator instantiation
op.inputs.field.connect(my_field)
my_mesh = op.outputs.mesh()
#include "dpf_api.h"

ansys::dpf::Operator op("GetSupportFromField"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::MeshedRegion my_mesh = op.getOutput<ansys::dpf::MeshedRegion>(0);

result: part internal energy (LSDyna)

Description

Read Part Internal Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
entity_scopingname
(scoping)expected type(s)

entity (part for matsum, interface for rcforc) where the result will be scoped

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: part_internal_energy
  • full name: result.part_internal_energy
  • internal name: M_IE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.part_internal_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.entity_scoping.Connect(my_entity_scoping)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.part_internal_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.entity_scoping.connect(my_entity_scoping)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("M_IE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_entity_scoping);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: part momentum (LSDyna)

Description

Read Part Momentum (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
entity_scopingname
(scoping)expected type(s)

entity (part for matsum, interface for rcforc) where the result will be scoped

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: part_momentum
  • full name: result.part_momentum
  • internal name: M_MV
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.part_momentum() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.entity_scoping.Connect(my_entity_scoping)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.part_momentum() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.entity_scoping.connect(my_entity_scoping)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("M_MV"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_entity_scoping);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: creep strain max_shear

Description

Reads/computes element nodal component creep strains, average it on nodes (by default) and computes its invariants.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain_max_shear
  • full name: result.creep_strain_max_shear
  • internal name: EPCR_max_shear
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain_max_shear() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain_max_shear() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPCR_max_shear"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: default value

Description

Default return value from input pin 1 to output pin 0 if there is nothing on input pin 0.

Inputs

pin 0optional
forced_valuename
pin 1requested
default_valuename

Outputs

pin 0requested
outputname

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: default_value
  • full name: utility.default_value
  • internal name: default_value
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.default_value() # operator instantiation
op.inputs.forced_value.Connect(my_forced_value)
op.inputs.default_value.Connect(my_default_value)
my_output = op.outputs.output.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.default_value() # operator instantiation
op.inputs.forced_value.connect(my_forced_value)
op.inputs.default_value.connect(my_default_value)
my_output = op.outputs.output()
#include "dpf_api.h"

ansys::dpf::Operator op("default_value"); // operator instantiation
op.connect(0, my_forced_value);
op.connect(1, my_default_value);
ansys::dpf::Any my_output = op.getOutput<ansys::dpf::Any>(0);

averaging: elemental nodal to nodal elemental (fields container)

Description

Transforms Elemental Nodal fields to Nodal Elemental fields. The result is computed on a given node's scoping.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
mesh_scopingname
(scoping)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: elemental_nodal_to_nodal_elemental_fc
  • full name: averaging.elemental_nodal_to_nodal_elemental_fc
  • internal name: ElementalNodal_To_NodalElemental_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.elemental_nodal_to_nodal_elemental_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.elemental_nodal_to_nodal_elemental_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ElementalNodal_To_NodalElemental_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh_scoping);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: rms velocity

Description

Read RMS Velocity by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: rms_velocity
  • full name: result.rms_velocity
  • internal name: V_RMS
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.rms_velocity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.rms_velocity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("V_RMS"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: acceleration X

Description

Read/compute nodal accelerations X component of the vector (1st component) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: acceleration_X
  • full name: result.acceleration_X
  • internal name: AX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.acceleration_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.acceleration_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("AX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: poynting vector

Description

Compute the Poynting Vector

Inputs

pin 0requested
fields_containerAname
(fields_container)expected type(s)
pin 1requested
fields_containerBname
(fields_container)expected type(s)
pin 2requested
fields_containerCname
(fields_container)expected type(s)
pin 3requested
fields_containerDname
(fields_container)expected type(s)
pin 4optional
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

the mesh region in this pin have to be boundary or skin mesh

pin 5optional
int32name
(int32)expected type(s)

load step number, if it's specified, the Poynting Vector is computed only on the substeps of this step

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: poynting_vector
  • full name: result.poynting_vector
  • internal name: PoyntingVector
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.poynting_vector() # operator instantiation
op.inputs.fields_containerA.Connect(my_fields_containerA)
op.inputs.fields_containerB.Connect(my_fields_containerB)
op.inputs.fields_containerC.Connect(my_fields_containerC)
op.inputs.fields_containerD.Connect(my_fields_containerD)
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.int32.Connect(my_int32)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.poynting_vector() # operator instantiation
op.inputs.fields_containerA.connect(my_fields_containerA)
op.inputs.fields_containerB.connect(my_fields_containerB)
op.inputs.fields_containerC.connect(my_fields_containerC)
op.inputs.fields_containerD.connect(my_fields_containerD)
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.int32.connect(my_int32)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("PoyntingVector"); // operator instantiation
op.connect(0, my_fields_containerA);
op.connect(1, my_fields_containerB);
op.connect(2, my_fields_containerC);
op.connect(3, my_fields_containerD);
op.connect(4, my_abstract_meshed_region);
op.connect(5, my_int32);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: extract sub fields container

Description

Creates a new fields container with all the fields corresponding to the label space in input 1. If pin 1 is not defined, pin 0 input will be copied to the output.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

fields_container

pin 1optional
label_spacename
(label_space | scoping)expected type(s)

Label space, or scoping defining the label space (scoping location), values to keep (scoping IDs)

pin 2optional
collapse_labelsname
(bool)expected type(s)

If set to true (default) the input label space (scoping location) is suppressed from the output fields container, otherwise, label space is kept.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

fields_container

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: extract_sub_fc
  • full name: utility.extract_sub_fc
  • internal name: extract_sub_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.extract_sub_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.label_space.Connect(my_label_space)
op.inputs.collapse_labels.Connect(my_collapse_labels)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.extract_sub_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.label_space.connect(my_label_space)
op.inputs.collapse_labels.connect(my_collapse_labels)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("extract_sub_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_label_space);
op.connect(2, my_collapse_labels);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: total strain (LSDyna)

Description

Read/compute Total strain (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3ssd,d3plot,d3psd,binout

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: total_strain
  • full name: result.total_strain
  • internal name: EL
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.total_strain() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.total_strain() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EL"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: extract sub meshes container

Description

Creates a new meshes container with all the meshed regions corresponding to the label space in input 1. If pin 1 is not defined, pin 0 input will be copied to the output.

Inputs

pin 0requested
meshesname
(meshes_container)expected type(s)

meshes

pin 1optional
label_spacename
(label_space | scoping)expected type(s)

Label space, or scoping defining the label space (scoping location), values to keep (scoping IDs)

pin 2optional
collapse_labelsname
(bool)expected type(s)

If set to true (default) the input label space (scoping location) is suppressed from the output meshes container, otherwise, label space is kept.

Outputs

pin 0requested
meshes_containername
(meshes_container)expected type(s)

meshes

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: extract_sub_mc
  • full name: utility.extract_sub_mc
  • internal name: extract_sub_mc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.extract_sub_mc() # operator instantiation
op.inputs.meshes.Connect(my_meshes)
op.inputs.label_space.Connect(my_label_space)
op.inputs.collapse_labels.Connect(my_collapse_labels)
my_meshes_container = op.outputs.meshes_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.extract_sub_mc() # operator instantiation
op.inputs.meshes.connect(my_meshes)
op.inputs.label_space.connect(my_label_space)
op.inputs.collapse_labels.connect(my_collapse_labels)
my_meshes_container = op.outputs.meshes_container()
#include "dpf_api.h"

ansys::dpf::Operator op("extract_sub_mc"); // operator instantiation
op.connect(0, my_meshes);
op.connect(1, my_label_space);
op.connect(2, my_collapse_labels);
ansys::dpf::MeshesContainer my_meshes_container = op.getOutput<ansys::dpf::MeshesContainer>(0);

averaging: elemental difference (fields container)

Description

Transforms an Elemental Nodal or Nodal field into an Elemental field. Each elemental value is the maximum difference between the unaveraged or averaged (depending on the input fields) computed result for all nodes in this element. The result is computed on a given element scoping. If the input fields are mixed shell/solid, and the shell's layers are not specified as collapsed, then the fields are split by element shape and the output fields container has an elshape label.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

The mesh region in this pin is used to perform the averaging, used if there is no fields support.

pin 3optional
scopingname
(scoping | scopings_container)expected type(s)

Average only on these elements. If it is scoping container, the label must correspond to the one of the fields container.

pin 10optional
collapse_shell_layersname
(bool)expected type(s)

If true, the data across different shell layers is averaged as well (default is false).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: elemental_difference_fc
  • full name: averaging.elemental_difference_fc
  • internal name: elemental_difference_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.elemental_difference_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.scoping.Connect(my_scoping)
op.inputs.collapse_shell_layers.Connect(my_collapse_shell_layers)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.elemental_difference_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.scoping.connect(my_scoping)
op.inputs.collapse_shell_layers.connect(my_collapse_shell_layers)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("elemental_difference_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(3, my_scoping);
op.connect(10, my_collapse_shell_layers);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: extract sub scopings container

Description

Creates a new scopings container with all the scopings corresponding to the label space in input 1. If pin 1 is not defined, pin 0 input will be copied to the output.

Inputs

pin 0requested
scopings_containername
(scopings_container)expected type(s)

scopings_container

pin 1optional
label_spacename
(label_space | scoping)expected type(s)

Label space, or scoping defining the label space (scoping location), values to keep (scoping IDs)

pin 2optional
collapse_labelsname
(bool)expected type(s)

If set to true (default) the input label space (scoping location) is suppressed from the output scopings container, otherwise, label space is kept.

Outputs

pin 0requested
scopings_containername
(scopings_container)expected type(s)

scopings_container

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: extract_sub_sc
  • full name: utility.extract_sub_sc
  • internal name: extract_sub_sc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.extract_sub_sc() # operator instantiation
op.inputs.scopings_container.Connect(my_scopings_container)
op.inputs.label_space.Connect(my_label_space)
op.inputs.collapse_labels.Connect(my_collapse_labels)
my_scopings_container = op.outputs.scopings_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.extract_sub_sc() # operator instantiation
op.inputs.scopings_container.connect(my_scopings_container)
op.inputs.label_space.connect(my_label_space)
op.inputs.collapse_labels.connect(my_collapse_labels)
my_scopings_container = op.outputs.scopings_container()
#include "dpf_api.h"

ansys::dpf::Operator op("extract_sub_sc"); // operator instantiation
op.connect(0, my_scopings_container);
op.connect(1, my_label_space);
op.connect(2, my_collapse_labels);
ansys::dpf::ScopingsContainer my_scopings_container = op.getOutput<ansys::dpf::ScopingsContainer>(0);

utility: compute time scoping

Description

Computes the time frequency scoping (made of set IDs) necessary to interpolate on a list of time or frequencies.

Inputs

pin 0requested
time_freq_valuesname
(double | vector | field | time_freq_support)expected type(s)

List of frequencies or times needed. To specify load steps, put a field (and not a list) in input with a scoping located on "TimeFreq_steps".

pin 2optional
stepname
(int32)expected type(s)
pin 4optional
interpolation_typename
(int32)expected type(s)

1:ramped' or 2:stepped', default is ramped

pin 8requested
time_freq_supportname
(time_freq_support)expected type(s)

Outputs

pin 0requested
scopingname
(scoping)expected type(s)

time_scoping

pin 1requested
fieldname
(field)expected type(s)

time_freq_values

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: compute_time_scoping
  • full name: utility.compute_time_scoping
  • internal name: compute_time_scoping
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.compute_time_scoping() # operator instantiation
op.inputs.time_freq_values.Connect(my_time_freq_values)
op.inputs.step.Connect(my_step)
op.inputs.interpolation_type.Connect(my_interpolation_type)
op.inputs.time_freq_support.Connect(my_time_freq_support)
my_scoping = op.outputs.scoping.GetData()
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.compute_time_scoping() # operator instantiation
op.inputs.time_freq_values.connect(my_time_freq_values)
op.inputs.step.connect(my_step)
op.inputs.interpolation_type.connect(my_interpolation_type)
op.inputs.time_freq_support.connect(my_time_freq_support)
my_scoping = op.outputs.scoping()
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_time_scoping"); // operator instantiation
op.connect(0, my_time_freq_values);
op.connect(2, my_step);
op.connect(4, my_interpolation_type);
op.connect(8, my_time_freq_support);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(0);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(1);

result: static pressure

Description

Read Static Pressure by calling the readers defined by the datasources.

Supported file types

  • cff: flprj,cas

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: static_pressure
  • full name: result.static_pressure
  • internal name: P_S
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.static_pressure() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.static_pressure() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("P_S"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain

Description

Read/compute element nodal component elastic strains by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst,cms,mode,rdsp,rfrq,dsub

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain
  • full name: result.elastic_strain
  • internal name: EPEL
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPEL"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: turbulent viscosity

Description

Read Turbulent Viscosity by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: turbulent_viscosity
  • full name: result.turbulent_viscosity
  • internal name: MUT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.turbulent_viscosity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.turbulent_viscosity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MUT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: window bartlett (fields container)

Description

Apply bartlett windowing on a given FieldsContainer having time label or a Field located on time. Assume that time sampling is evenly spaced (use time_freq_interpolation before otherwise).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: window_bartlett_fc
  • full name: math.window_bartlett_fc
  • internal name: window::bartlett_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.window_bartlett_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.window_bartlett_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("window::bartlett_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: part hourglass energy (LSDyna)

Description

Read Part Hourglass Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
entity_scopingname
(scoping)expected type(s)

entity (part for matsum, interface for rcforc) where the result will be scoped

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: part_hourglass_energy
  • full name: result.part_hourglass_energy
  • internal name: M_ENG_AHO
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.part_hourglass_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.entity_scoping.Connect(my_entity_scoping)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.part_hourglass_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.entity_scoping.connect(my_entity_scoping)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("M_ENG_AHO"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_entity_scoping);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: python generator

Description

Generates .py file with specifications for loaded plugin(s).

Inputs

pin 0requested
dll_source_pathname
(string)expected type(s)
pin 1requested
output_pathname
(string)expected type(s)
pin 2optional
load_symbolname
(string)expected type(s)
pin 3optional
library_keyname
(string)expected type(s)

Outputs

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: python_generator
  • full name: utility.python_generator
  • internal name: python_generator
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.python_generator() # operator instantiation
op.inputs.dll_source_path.Connect(my_dll_source_path)
op.inputs.output_path.Connect(my_output_path)
op.inputs.load_symbol.Connect(my_load_symbol)
op.inputs.library_key.Connect(my_library_key)
from ansys.dpf import core as dpf 

op = dpf.operators.utility.python_generator() # operator instantiation
op.inputs.dll_source_path.connect(my_dll_source_path)
op.inputs.output_path.connect(my_output_path)
op.inputs.load_symbol.connect(my_load_symbol)
op.inputs.library_key.connect(my_library_key)
#include "dpf_api.h"

ansys::dpf::Operator op("python_generator"); // operator instantiation
op.connect(0, my_dll_source_path);
op.connect(1, my_output_path);
op.connect(2, my_load_symbol);
op.connect(3, my_library_key);

geo: elements volume

Description

Compute the measure of the Elements (volume for 3D elements, surface for 2D elements or length for 1D elements) using default shape functions, except for polyhedrons.

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)
pin 1requested
mesh_scopingname
(scoping)expected type(s)

If not provided, the measure of all elements for the mesh is computed. If provided, the Scoping needs to have "Elemental" location.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: geo
  • plugin: core
  • scripting name: elements_volume
  • full name: geo.elements_volume
  • internal name: element::volume
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.elements_volume() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.elements_volume() # operator instantiation
op.inputs.mesh.connect(my_mesh)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("element::volume"); // operator instantiation
op.connect(0, my_mesh);
op.connect(1, my_mesh_scoping);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: make overall

Description

Extracts a value from a field and makes a new field containing only this value, with the associated scoping's location set as 'overall'.

Inputs

pin 0requested
fieldname
(field)expected type(s)
pin 1requested
idname
(int32)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: make_overall
  • full name: utility.make_overall
  • internal name: make_overall
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.make_overall() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.id.Connect(my_id)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.make_overall() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.id.connect(my_id)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("make_overall"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_id);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: stress

Description

Read/compute element nodal component stresses by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3ssd,d3psd,d3plot,binout
  • mapdl: dsub,rst,cms,mode,rdsp,rfrq

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress
  • full name: result.stress
  • internal name: S
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("S"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: pressure

Description

Read/compute Pressure by calling the readers defined by the datasources.

Supported file types

  • cgns: cgns
  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: pressure
  • full name: result.pressure
  • internal name: Pressure
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.pressure() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.pressure() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("Pressure"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: stress X

Description

Read/compute element nodal component stresses XX normal component (00 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress_X
  • full name: result.stress_X
  • internal name: SX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("SX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: gasket thermal closure XZ

Description

Read/compute elemental gasket thermal closure XZ shear component (02 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_thermal_closure_XZ
  • full name: result.gasket_thermal_closure_XZ
  • internal name: GKTHXZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_thermal_closure_XZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_thermal_closure_XZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKTHXZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: stress Y

Description

Read/compute element nodal component stresses YY normal component (11 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress_Y
  • full name: result.stress_Y
  • internal name: SY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("SY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: stress Z

Description

Read/compute element nodal component stresses ZZ normal component (22 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress_Z
  • full name: result.stress_Z
  • internal name: SZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("SZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: gasket thermal closure XY

Description

Read/compute elemental gasket thermal closure XY shear component (01 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_thermal_closure_XY
  • full name: result.gasket_thermal_closure_XY
  • internal name: GKTHXY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_thermal_closure_XY() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_thermal_closure_XY() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKTHXY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: stress XY

Description

Read/compute element nodal component stresses XY shear component (01 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress_XY
  • full name: result.stress_XY
  • internal name: SXY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_XY() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_XY() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("SXY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: stress YZ

Description

Read/compute element nodal component stresses YZ shear component (12 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress_YZ
  • full name: result.stress_YZ
  • internal name: SYZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_YZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_YZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("SYZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: stress XZ

Description

Read/compute element nodal component stresses XZ shear component (02 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress_XZ
  • full name: result.stress_XZ
  • internal name: SXZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_XZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_XZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("SXZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: stress principal 1

Description

Read/compute element nodal component stresses 1st principal component by calling the readers defined by the datasources and computing its eigen values.

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress_principal_1
  • full name: result.stress_principal_1
  • internal name: S1
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_principal_1() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_principal_1() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("S1"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: merge string fields

Description

Assembles a set of string fields into a unique one.

Inputs

pin 0, 1...requested, ellipsis
string_fieldsname
(vector> | string_field)expected type(s)

Either a a vector of string fields to merge or string fields from pin 0 to ...

Outputs

pin 0requested
string_fieldname
(string_field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_string_fields
  • full name: utility.merge_string_fields
  • internal name: merge::string_field
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_string_fields() # operator instantiation
op.inputs.string_fields1.Connect(my_string_fields_1)
op.inputs.string_fields2.Connect(my_string_fields_2)
my_string_field = op.outputs.string_field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_string_fields() # operator instantiation
op.inputs.string_fields1.connect(my_string_fields_1)
op.inputs.string_fields2.connect(my_string_fields_2)
my_string_field = op.outputs.string_field()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::string_field"); // operator instantiation
op.connect(0, my_string_fields_1);
op.connect(1, my_string_fields_2);
ansys::dpf::StringField my_string_field = op.getOutput<ansys::dpf::StringField>(0);

result: stress principal 2

Description

Read/compute element nodal component stresses 2nd principal component by calling the readers defined by the datasources and computing its eigen values.

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress_principal_2
  • full name: result.stress_principal_2
  • internal name: S2
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_principal_2() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_principal_2() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("S2"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: stress principal 3

Description

Read/compute element nodal component stresses 3rd principal component by calling the readers defined by the datasources and computing its eigen values.

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress_principal_3
  • full name: result.stress_principal_3
  • internal name: S3
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_principal_3() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_principal_3() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("S3"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: tangential contact moment

Description

Read/compute tangential contact moment by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: tangential_contact_moment
  • full name: result.tangential_contact_moment
  • internal name: CFTTAN
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.tangential_contact_moment() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.tangential_contact_moment() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("CFTTAN"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

invariant: convertnum bcs to nod

Description

Converts a fields container from BCS to NOD ordering.

Inputs

pin 2requested
fields_containername
(fields_container)expected type(s)

fields_container

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Data_sources (must contain the full file).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: invariant
  • plugin: mapdl
  • scripting name: convertnum_bcs_to_nod
  • full name: invariant.convertnum_bcs_to_nod
  • internal name: convertnum_bcs_to_nod
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.convertnum_bcs_to_nod() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.data_sources.Connect(my_data_sources)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.convertnum_bcs_to_nod() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.data_sources.connect(my_data_sources)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("convertnum_bcs_to_nod"); // operator instantiation
op.connect(2, my_fields_container);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: stress von mises

Description

Reads/computes element nodal component stresses, average it on nodes (by default) and computes its invariants.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress_von_mises
  • full name: result.stress_von_mises
  • internal name: S_eqv
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_von_mises() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_von_mises() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("S_eqv"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: gasket stress

Description

Read/compute elemental gasket stress by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_stress
  • full name: result.gasket_stress
  • internal name: GKS
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_stress() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_stress() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKS"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: contact fluid penetration pressure

Description

Read/compute element actual applied fluid penetration pressure by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rth,rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: contact_fluid_penetration_pressure
  • full name: result.contact_fluid_penetration_pressure
  • internal name: ECT_FRES
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.contact_fluid_penetration_pressure() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.contact_fluid_penetration_pressure() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ECT_FRES"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: gasket stress X

Description

Read/compute elemental gasket stress XX normal component (00 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_stress_X
  • full name: result.gasket_stress_X
  • internal name: GKSX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_stress_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_stress_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKSX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: gasket stress XY

Description

Read/compute elemental gasket stress XY shear component (01 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_stress_XY
  • full name: result.gasket_stress_XY
  • internal name: GKSXY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_stress_XY() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_stress_XY() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKSXY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: gasket deformation

Description

Read/compute elemental gasket deformation by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_deformation
  • full name: result.gasket_deformation
  • internal name: GKD
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_deformation() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_deformation() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKD"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: gasket deformation X

Description

Read/compute elemental gasket deformation XX normal component (00 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_deformation_X
  • full name: result.gasket_deformation_X
  • internal name: GKDX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_deformation_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_deformation_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKDX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

geo: elements facets surfaces over time

Description

Calculates for a mesh, the surface of each element's facet over time for each specified time step. The output is a new mesh made with only surface elements.

Inputs

pin 1optional
scopingname
(scoping)expected type(s)
pin 2optional
displacementname
(fields_container)expected type(s)

Displacement field's container.

pin 7optional
meshname
(abstract_meshed_region)expected type(s)

Mesh must be defined if the displacement field's container does not contain it, or if there is no displacement.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Surfaces field.

pin 1requested
meshname
(abstract_meshed_region)expected type(s)

Mesh made of surface elements only.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: geo
  • plugin: core
  • scripting name: elements_facets_surfaces_over_time
  • full name: geo.elements_facets_surfaces_over_time
  • internal name: surfaces_provider
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.elements_facets_surfaces_over_time() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.displacement.Connect(my_displacement)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
my_mesh = op.outputs.mesh.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.elements_facets_surfaces_over_time() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.displacement.connect(my_displacement)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
my_mesh = op.outputs.mesh()
#include "dpf_api.h"

ansys::dpf::Operator op("surfaces_provider"); // operator instantiation
op.connect(1, my_scoping);
op.connect(2, my_displacement);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::MeshedRegion my_mesh = op.getOutput<ansys::dpf::MeshedRegion>(1);

result: gasket deformation XY

Description

Read/compute elemental gasket deformation XY shear component (01 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_deformation_XY
  • full name: result.gasket_deformation_XY
  • internal name: GKDXY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_deformation_XY() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_deformation_XY() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKDXY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: creep strain X

Description

Read/compute element nodal component creep strains XX normal component (00 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain_X
  • full name: result.creep_strain_X
  • internal name: EPCRX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPCRX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

metadata: property field provider by property name

Description

Provides the property values for a set of elements for a defined property name.

Inputs

pin 1optional
mesh_scopingname
(scoping)expected type(s)

scoping that defines the set of elements to fetch the property values for. If not specified, applied on all the elements of the mesh.

pin 3optional
streams_containername
(streams_container)expected type(s)

optional if using a dataSources

pin 4requested
data_sourcesname
(data_sources)expected type(s)

optional if using a streamsContainer

pin 13requested
property_namename
(string)expected type(s)

property to read, that can be the following: elements_connectivity, nodes_connectivity, material, element_type, apdl_section_id, apdl_real_id, apdl_esys_id, mapdl_element_type, mapdl_element_type_id, harmonic_index, step, substep, keyopt_i (i = 1 -> 18).

Outputs

pin 0requested
property_fieldname
(property_field)expected type(s)

property field

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: property_field_provider_by_name
  • full name: metadata.property_field_provider_by_name
  • internal name: property_field_provider_by_name
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.property_field_provider_by_name() # operator instantiation
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.property_name.Connect(my_property_name)
my_property_field = op.outputs.property_field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.property_field_provider_by_name() # operator instantiation
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.property_name.connect(my_property_name)
my_property_field = op.outputs.property_field()
#include "dpf_api.h"

ansys::dpf::Operator op("property_field_provider_by_name"); // operator instantiation
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(13, my_property_name);
ansys::dpf::PropertyField my_property_field = op.getOutput<ansys::dpf::PropertyField>(0);

result: gasket deformation XZ

Description

Read/compute elemental gasket deformation XZ shear component (02 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_deformation_XZ
  • full name: result.gasket_deformation_XZ
  • internal name: GKDXZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_deformation_XZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_deformation_XZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKDXZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

mesh: mesh provider

Description

Reads a mesh from result files.

Supported file types

  • cff: cas,flprj
  • cgns: cgns
  • hdf5: h5dpf
  • mapdl: rfrq,rdsp,cms,rst,mode,rth,dsub
  • vtk: vtk

Inputs

pin 0optional
time_scopingname
(int32)expected type(s)

Optional time/frequency set ID of the mesh, supported for adaptative meshes.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

If 1, cyclic symmetry is ignored. If 2, cyclic expansion is done (default is 1).

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids with one entity (vector) or region scoping with one id (scoping) (region corresponds to zone for Fluid results or part for LSDyna results).

pin 200optional
lazinessname
(abstract_data_tree)expected type(s)

configurate whether lazy evaluation can be performed and to what extent. Supported attributes are:

  • "num_named_selections"->num named selection to read (-1 is all, int32, default si -1), careful: the other named selections will not be available, use mesh_property_provider Operator to read them.
  • all mesh property fields "mat", "named_selection", "apdl_element_type", "section"-> if set to 1 these properties will not be read and a workflow will be bounded to the properties to be evaluated on demand, with 0 they are read (default is 0).
  • "all_available_properties" option set to 0 will return all possible properties

Outputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: mesh_provider
  • full name: mesh.mesh_provider
  • internal name: mesh_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.mesh_provider() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.laziness.Connect(my_laziness)
my_mesh = op.outputs.mesh.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.mesh_provider() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.laziness.connect(my_laziness)
my_mesh = op.outputs.mesh()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh_provider"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(14, my_read_cyclic);
op.connect(25, my_region_scoping);
op.connect(200, my_laziness);
ansys::dpf::MeshedRegion my_mesh = op.getOutput<ansys::dpf::MeshedRegion>(0);

result: gasket inelastic closure

Description

Read/compute elemental gasket inelastic closure by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_inelastic_closure
  • full name: result.gasket_inelastic_closure
  • internal name: GKDI
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_inelastic_closure() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_inelastic_closure() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKDI"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: export symbolic workflow

Description

Transforms a Workflow into a symbolic Workflow and writes it to a file (if a path is set in input) or string

Inputs

pin 0requested
workflowname
(workflow)expected type(s)
pin 1optional
pathname
(string)expected type(s)
pin 2optional
formatname
(int32)expected type(s)

0 is ASCII format and 1 is binary, default is 0.

pin 3optional
optionsname
(int32)expected type(s)

1 copies connections with its data, 2 forwards named inputs and outputs names, 7 copies connections of named inputs and ouputs with their data. default is 7.

Outputs

pin 0requested
data_sourcesname
(data_sources | string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: export_symbolic_workflow
  • full name: serialization.export_symbolic_workflow
  • internal name: export_symbolic_workflow
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.export_symbolic_workflow() # operator instantiation
op.inputs.workflow.Connect(my_workflow)
op.inputs.path.Connect(my_path)
op.inputs.format.Connect(my_format)
op.inputs.options.Connect(my_options)
my_data_sources = op.outputs.data_sources.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.export_symbolic_workflow() # operator instantiation
op.inputs.workflow.connect(my_workflow)
op.inputs.path.connect(my_path)
op.inputs.format.connect(my_format)
op.inputs.options.connect(my_options)
my_data_sources = op.outputs.data_sources()
#include "dpf_api.h"

ansys::dpf::Operator op("export_symbolic_workflow"); // operator instantiation
op.connect(0, my_workflow);
op.connect(1, my_path);
op.connect(2, my_format);
op.connect(3, my_options);
ansys::dpf::DataSources my_data_sources = op.getOutput<ansys::dpf::DataSources>(0);

result: write cms rbd file

Description

Write the invariant terms and the model data in a cms_rbd file

Inputs

pin 0requested
model_dataname
(property_field)expected type(s)

data describing the finite element model

pin 1requested
center_of_massname
(field)expected type(s)

center of mass of the body

pin 2requested
inertia_reliefname
(field)expected type(s)

inertia matrix

pin 3requested
model_sizename
(double)expected type(s)

size of the diagonal box containing the body

pin 4requested
master_node_coordinatesname
(vector)expected type(s)
pin 5requested
v_trsfname
(vector)expected type(s)

translational and rotational shape functions

pin 6requested
k_matname
(field)expected type(s)
pin 7requested
mass_matname
(field)expected type(s)
pin 8requested
c_matname
(field)expected type(s)
pin 9requested
rhsname
(field)expected type(s)
pin 10requested
dnname
(vector)expected type(s)
pin 11requested
dr_cross_nname
(vector)expected type(s)
pin 12requested
drnname
(vector)expected type(s)
pin 13requested
dn_cross_nname
(vector)expected type(s)
pin 14requested
dnx_yname
(vector)expected type(s)
pin 15requested
dny_yname
(vector)expected type(s)
pin 16requested
dnz_yname
(vector)expected type(s)
pin 17requested
dyx_nname
(vector)expected type(s)
pin 18requested
dyy_nname
(vector)expected type(s)
pin 19requested
dyz_nname
(vector)expected type(s)
pin 20requested
dnxnname
(vector)expected type(s)
pin 21requested
dnynname
(vector)expected type(s)
pin 22requested
dnznname
(vector)expected type(s)
pin 23requested
file_pathname
(string)expected type(s)

path with cms_rbd extension where the export occurs

Outputs

pin 0requested
data_sourcesname
(data_sources)expected type(s)

Data Source containing the cms_rbd file generated.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: write_cms_rbd_file
  • full name: result.write_cms_rbd_file
  • internal name: write_cms_rbd_file
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.write_cms_rbd_file() # operator instantiation
op.inputs.model_data.Connect(my_model_data)
op.inputs.center_of_mass.Connect(my_center_of_mass)
op.inputs.inertia_relief.Connect(my_inertia_relief)
op.inputs.model_size.Connect(my_model_size)
op.inputs.master_node_coordinates.Connect(my_master_node_coordinates)
op.inputs.v_trsf.Connect(my_v_trsf)
op.inputs.k_mat.Connect(my_k_mat)
op.inputs.mass_mat.Connect(my_mass_mat)
op.inputs.c_mat.Connect(my_c_mat)
op.inputs.rhs.Connect(my_rhs)
op.inputs.dn.Connect(my_dn)
op.inputs.dr_cross_n.Connect(my_dr_cross_n)
op.inputs.drn.Connect(my_drn)
op.inputs.dn_cross_n.Connect(my_dn_cross_n)
op.inputs.dnx_y.Connect(my_dnx_y)
op.inputs.dny_y.Connect(my_dny_y)
op.inputs.dnz_y.Connect(my_dnz_y)
op.inputs.dyx_n.Connect(my_dyx_n)
op.inputs.dyy_n.Connect(my_dyy_n)
op.inputs.dyz_n.Connect(my_dyz_n)
op.inputs.dnxn.Connect(my_dnxn)
op.inputs.dnyn.Connect(my_dnyn)
op.inputs.dnzn.Connect(my_dnzn)
op.inputs.file_path.Connect(my_file_path)
my_data_sources = op.outputs.data_sources.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.write_cms_rbd_file() # operator instantiation
op.inputs.model_data.connect(my_model_data)
op.inputs.center_of_mass.connect(my_center_of_mass)
op.inputs.inertia_relief.connect(my_inertia_relief)
op.inputs.model_size.connect(my_model_size)
op.inputs.master_node_coordinates.connect(my_master_node_coordinates)
op.inputs.v_trsf.connect(my_v_trsf)
op.inputs.k_mat.connect(my_k_mat)
op.inputs.mass_mat.connect(my_mass_mat)
op.inputs.c_mat.connect(my_c_mat)
op.inputs.rhs.connect(my_rhs)
op.inputs.dn.connect(my_dn)
op.inputs.dr_cross_n.connect(my_dr_cross_n)
op.inputs.drn.connect(my_drn)
op.inputs.dn_cross_n.connect(my_dn_cross_n)
op.inputs.dnx_y.connect(my_dnx_y)
op.inputs.dny_y.connect(my_dny_y)
op.inputs.dnz_y.connect(my_dnz_y)
op.inputs.dyx_n.connect(my_dyx_n)
op.inputs.dyy_n.connect(my_dyy_n)
op.inputs.dyz_n.connect(my_dyz_n)
op.inputs.dnxn.connect(my_dnxn)
op.inputs.dnyn.connect(my_dnyn)
op.inputs.dnzn.connect(my_dnzn)
op.inputs.file_path.connect(my_file_path)
my_data_sources = op.outputs.data_sources()
#include "dpf_api.h"

ansys::dpf::Operator op("write_cms_rbd_file"); // operator instantiation
op.connect(0, my_model_data);
op.connect(1, my_center_of_mass);
op.connect(2, my_inertia_relief);
op.connect(3, my_model_size);
op.connect(4, my_master_node_coordinates);
op.connect(5, my_v_trsf);
op.connect(6, my_k_mat);
op.connect(7, my_mass_mat);
op.connect(8, my_c_mat);
op.connect(9, my_rhs);
op.connect(10, my_dn);
op.connect(11, my_dr_cross_n);
op.connect(12, my_drn);
op.connect(13, my_dn_cross_n);
op.connect(14, my_dnx_y);
op.connect(15, my_dny_y);
op.connect(16, my_dnz_y);
op.connect(17, my_dyx_n);
op.connect(18, my_dyy_n);
op.connect(19, my_dyz_n);
op.connect(20, my_dnxn);
op.connect(21, my_dnyn);
op.connect(22, my_dnzn);
op.connect(23, my_file_path);
ansys::dpf::DataSources my_data_sources = op.getOutput<ansys::dpf::DataSources>(0);

result: gasket inelastic closure X

Description

Read/compute elemental gasket inelastic closure XX normal component (00 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_inelastic_closure_X
  • full name: result.gasket_inelastic_closure_X
  • internal name: GKDIX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_inelastic_closure_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_inelastic_closure_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKDIX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

mesh: beam properties

Description

Reads the beam's properties from the result files contained in the streams or data sources.

Supported file types

  • mapdl: rst

Inputs

pin 3optional
streamsname
(streams_container)expected type(s)

Result file container allowed to be kept open to cache data.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Result file path container, used if no streams are set.

Outputs

pin 0requested
mesh_outname
(abstract_meshed_region)expected type(s)

This mesh updates a new map containing a field of the beam's properties if there is at least one beam in mesh.

pin 1requested
field_type_section_idname
(field)expected type(s)

This field contains the section ID of beams. 1:REC; 3:CSOLID, 4:CTUBE, 5:CHAN, 6:Z, 7:L, 8:I, 9:T, 11:HATS, 12:HREC.

pin 2requested
field_areaname
(field)expected type(s)

This field contains the area of beams.

pin 3requested
field_moment_inertianame
(field)expected type(s)

This field contains the inertia moment of beams. Iyy, Iyz, Izz.

pin 4requested
field_geometryname
(field)expected type(s)

This field contains the geometry of beams. REC:b,h. CSOLID:Ri. CTUBE:Ri, Re. CHAN:w1,w2,w3,t1,t2,t3. Z:w1,w2,w3,t1,t2,t3. L:w1,w2,t1,t2. I:w1,w2,w3,t1,t2,t3. T:w1,w2,t1,t2. HATS: w1,w2,w3,w4,t1,t2,t3,t4. HREC:w1,w2,t1,t2,t3,t4.

pin 5requested
field_young_modulusname
(field)expected type(s)

This field contains the Young's modulus of beams.

pin 6requested
field_poisson_rationame
(field)expected type(s)

This field contains the Poisson's ratio of beams.

pin 7requested
field_shear_modulusname
(field)expected type(s)

This field contains the Shear Modulus of beams.

pin 8requested
field_beam_lengthname
(field)expected type(s)

This field contains the length of beams.

pin 9requested
field_torsion_constantname
(field)expected type(s)

This field contains the Torsion Constant of beams.

pin 10requested
field_warping_constantname
(field)expected type(s)

This field contains the Warping Constant of beams.

pin 11requested
field_offset_typename
(field)expected type(s)

This field contains offset type of beams.

pin 12requested
field_offset_yname
(field)expected type(s)

This field contains offset y of beams.

pin 13requested
field_offset_zname
(field)expected type(s)

This field contains offset z of beams.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: beam_properties
  • full name: mesh.beam_properties
  • internal name: beam_properties
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.beam_properties() # operator instantiation
op.inputs.streams.Connect(my_streams)
op.inputs.data_sources.Connect(my_data_sources)
my_mesh_out = op.outputs.mesh_out.GetData()
my_field_type_section_id = op.outputs.field_type_section_id.GetData()
my_field_area = op.outputs.field_area.GetData()
my_field_moment_inertia = op.outputs.field_moment_inertia.GetData()
my_field_geometry = op.outputs.field_geometry.GetData()
my_field_young_modulus = op.outputs.field_young_modulus.GetData()
my_field_poisson_ratio = op.outputs.field_poisson_ratio.GetData()
my_field_shear_modulus = op.outputs.field_shear_modulus.GetData()
my_field_beam_length = op.outputs.field_beam_length.GetData()
my_field_torsion_constant = op.outputs.field_torsion_constant.GetData()
my_field_warping_constant = op.outputs.field_warping_constant.GetData()
my_field_offset_type = op.outputs.field_offset_type.GetData()
my_field_offset_y = op.outputs.field_offset_y.GetData()
my_field_offset_z = op.outputs.field_offset_z.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.beam_properties() # operator instantiation
op.inputs.streams.connect(my_streams)
op.inputs.data_sources.connect(my_data_sources)
my_mesh_out = op.outputs.mesh_out()
my_field_type_section_id = op.outputs.field_type_section_id()
my_field_area = op.outputs.field_area()
my_field_moment_inertia = op.outputs.field_moment_inertia()
my_field_geometry = op.outputs.field_geometry()
my_field_young_modulus = op.outputs.field_young_modulus()
my_field_poisson_ratio = op.outputs.field_poisson_ratio()
my_field_shear_modulus = op.outputs.field_shear_modulus()
my_field_beam_length = op.outputs.field_beam_length()
my_field_torsion_constant = op.outputs.field_torsion_constant()
my_field_warping_constant = op.outputs.field_warping_constant()
my_field_offset_type = op.outputs.field_offset_type()
my_field_offset_y = op.outputs.field_offset_y()
my_field_offset_z = op.outputs.field_offset_z()
#include "dpf_api.h"

ansys::dpf::Operator op("beam_properties"); // operator instantiation
op.connect(3, my_streams);
op.connect(4, my_data_sources);
ansys::dpf::MeshedRegion my_mesh_out = op.getOutput<ansys::dpf::MeshedRegion>(0);
ansys::dpf::Field my_field_type_section_id = op.getOutput<ansys::dpf::Field>(1);
ansys::dpf::Field my_field_area = op.getOutput<ansys::dpf::Field>(2);
ansys::dpf::Field my_field_moment_inertia = op.getOutput<ansys::dpf::Field>(3);
ansys::dpf::Field my_field_geometry = op.getOutput<ansys::dpf::Field>(4);
ansys::dpf::Field my_field_young_modulus = op.getOutput<ansys::dpf::Field>(5);
ansys::dpf::Field my_field_poisson_ratio = op.getOutput<ansys::dpf::Field>(6);
ansys::dpf::Field my_field_shear_modulus = op.getOutput<ansys::dpf::Field>(7);
ansys::dpf::Field my_field_beam_length = op.getOutput<ansys::dpf::Field>(8);
ansys::dpf::Field my_field_torsion_constant = op.getOutput<ansys::dpf::Field>(9);
ansys::dpf::Field my_field_warping_constant = op.getOutput<ansys::dpf::Field>(10);
ansys::dpf::Field my_field_offset_type = op.getOutput<ansys::dpf::Field>(11);
ansys::dpf::Field my_field_offset_y = op.getOutput<ansys::dpf::Field>(12);
ansys::dpf::Field my_field_offset_z = op.getOutput<ansys::dpf::Field>(13);

result: gasket inelastic closure XZ

Description

Read/compute elemental gasket inelastic closure XZ shear component (02 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_inelastic_closure_XZ
  • full name: result.gasket_inelastic_closure_XZ
  • internal name: GKDIXZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_inelastic_closure_XZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_inelastic_closure_XZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKDIXZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: gasket thermal closure

Description

Read/compute elemental gasket thermal closure by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_thermal_closure
  • full name: result.gasket_thermal_closure
  • internal name: GKTH
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_thermal_closure() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_thermal_closure() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKTH"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: gasket thermal closure X

Description

Read/compute elemental gasket thermal closure XX normal component (00 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: gasket_thermal_closure_X
  • full name: result.gasket_thermal_closure_X
  • internal name: GKTHX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.gasket_thermal_closure_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.gasket_thermal_closure_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GKTHX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain X

Description

Read/compute element nodal component elastic strains XX normal component (00 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain_X
  • full name: result.elastic_strain_X
  • internal name: EPELX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPELX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain Y

Description

Read/compute element nodal component elastic strains YY normal component (11 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain_Y
  • full name: result.elastic_strain_Y
  • internal name: EPELY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPELY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain Z

Description

Read/compute element nodal component elastic strains ZZ normal component (22 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain_Z
  • full name: result.elastic_strain_Z
  • internal name: EPELZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPELZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: merge weighted fields containers

Description

Assembles a set of fields containers into a unique one, applying a weight on the sum of the fields.

Inputs

pin -3optional
sum_mergename
(bool)expected type(s)

Default is false. If true, redundant quantities are summed instead of being ignored.

pin -2optional
merged_fields_supportname
(abstract_field_support)expected type(s)

Already merged field support.

pin -1optional
merged_fields_containers_supportname
(abstract_field_support | umap>)expected type(s)

Already merged fields containers support.

pin 0, 1...requested, ellipsis
fields_containersname
(vector> | fields_container)expected type(s)

A vector of fields containers to merge or fields containers from pin 0 to ...

pin 1000, 1001...requested, ellipsis
weightsname
(vector>> | class dataProcessing::DpfTypeCollection)expected type(s)

Weights to apply to each field from pin 1000 to ...

Outputs

pin 0requested
merged_fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
read_inputs_in_parallelIf this option is set to true, the operator's inputs will be evaluated in parallel.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the operator's inputs will be evaluated in parallel.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_weighted_fields_containers
  • full name: utility.merge_weighted_fields_containers
  • internal name: merge::weighted_fields_container
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_weighted_fields_containers() # operator instantiation
op.inputs.sum_merge.Connect(my_sum_merge)
op.inputs.merged_fields_support.Connect(my_merged_fields_support)
op.inputs.merged_fields_containers_support.Connect(my_merged_fields_containers_support)
op.inputs.fields_containers1.Connect(my_fields_containers_1)
op.inputs.fields_containers2.Connect(my_fields_containers_2)
op.inputs.weights1.Connect(my_weights_1)
op.inputs.weights2.Connect(my_weights_2)
my_merged_fields_container = op.outputs.merged_fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_weighted_fields_containers() # operator instantiation
op.inputs.sum_merge.connect(my_sum_merge)
op.inputs.merged_fields_support.connect(my_merged_fields_support)
op.inputs.merged_fields_containers_support.connect(my_merged_fields_containers_support)
op.inputs.fields_containers1.connect(my_fields_containers_1)
op.inputs.fields_containers2.connect(my_fields_containers_2)
op.inputs.weights1.connect(my_weights_1)
op.inputs.weights2.connect(my_weights_2)
my_merged_fields_container = op.outputs.merged_fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::weighted_fields_container"); // operator instantiation
op.connect(-3, my_sum_merge);
op.connect(-2, my_merged_fields_support);
op.connect(-1, my_merged_fields_containers_support);
op.connect(0, my_fields_containers_1);
op.connect(1, my_fields_containers_2);
op.connect(1000, my_weights_1);
op.connect(1001, my_weights_2);
ansys::dpf::FieldsContainer my_merged_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: min/max over time

Description

Evaluates minimum/maximum over time/frequency.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 5requested
int32name
(int32)expected type(s)

Define min or max.

Outputs

pin 0requested
field_container_1name
(fields_container)expected type(s)
pin 1optional
field_container_2name
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: mechanical::min_max_over_time
  • full name: math.mechanical::min_max_over_time
  • internal name: mechanical::min_max_over_time
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.mechanical::min_max_over_time() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.int32.Connect(my_int32)
my_field_container_1 = op.outputs.field_container_1.GetData()
my_field_container_2 = op.outputs.field_container_2.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.mechanical::min_max_over_time() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.int32.connect(my_int32)
my_field_container_1 = op.outputs.field_container_1()
my_field_container_2 = op.outputs.field_container_2()
#include "dpf_api.h"

ansys::dpf::Operator op("mechanical::min_max_over_time"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(5, my_int32);
ansys::dpf::FieldsContainer my_field_container_1 = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_field_container_2 = op.getOutput<ansys::dpf::FieldsContainer>(1);

utility: merge fields containers

Description

Assembles a set of fields containers into a unique one.

Inputs

pin -200optional
should_merge_named_selectionsname
(bool)expected type(s)

For some result files (such as RST), the scoping on names selection is duplicated through all the distributed files.If this pin is false, the merging process is skipped. If it is true, this scoping is merged. Default is true.

pin -3optional
sum_mergename
(bool)expected type(s)

Default is false. If true, redundant quantities are summed instead of being ignored.

pin -2optional
merged_fields_supportname
(abstract_field_support)expected type(s)

Already merged field support.

pin -1optional
merged_fields_containers_supportname
(abstract_field_support | umap>)expected type(s)

Already merged fields containers support.

pin 0, 1...requested, ellipsis
fields_containersname
(vector> | fields_container)expected type(s)

A vector of fields containers to merge or fields containers from pin 0 to ...

Outputs

pin 0requested
merged_fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
read_inputs_in_parallelIf this option is set to true, the operator's inputs will be evaluated in parallel.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the operator's inputs will be evaluated in parallel.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_fields_containers
  • full name: utility.merge_fields_containers
  • internal name: merge::fields_container
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_fields_containers() # operator instantiation
op.inputs.should_merge_named_selections.Connect(my_should_merge_named_selections)
op.inputs.sum_merge.Connect(my_sum_merge)
op.inputs.merged_fields_support.Connect(my_merged_fields_support)
op.inputs.merged_fields_containers_support.Connect(my_merged_fields_containers_support)
op.inputs.fields_containers1.Connect(my_fields_containers_1)
op.inputs.fields_containers2.Connect(my_fields_containers_2)
my_merged_fields_container = op.outputs.merged_fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_fields_containers() # operator instantiation
op.inputs.should_merge_named_selections.connect(my_should_merge_named_selections)
op.inputs.sum_merge.connect(my_sum_merge)
op.inputs.merged_fields_support.connect(my_merged_fields_support)
op.inputs.merged_fields_containers_support.connect(my_merged_fields_containers_support)
op.inputs.fields_containers1.connect(my_fields_containers_1)
op.inputs.fields_containers2.connect(my_fields_containers_2)
my_merged_fields_container = op.outputs.merged_fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::fields_container"); // operator instantiation
op.connect(-200, my_should_merge_named_selections);
op.connect(-3, my_sum_merge);
op.connect(-2, my_merged_fields_support);
op.connect(-1, my_merged_fields_containers_support);
op.connect(0, my_fields_containers_1);
op.connect(1, my_fields_containers_2);
ansys::dpf::FieldsContainer my_merged_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global energy ratio without eroded energy (LSDyna)

Description

Read Global Energy ratio without Eroded Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_energy_ratio_wo_eroded
  • full name: result.global_energy_ratio_wo_eroded
  • internal name: GLOB_ENG_ER
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_energy_ratio_wo_eroded() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_energy_ratio_wo_eroded() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_ENG_ER"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain XY

Description

Read/compute element nodal component elastic strains XY shear component (01 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain_XY
  • full name: result.elastic_strain_XY
  • internal name: EPELXY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_XY() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_XY() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPELXY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain YZ

Description

Read/compute element nodal component elastic strains YZ shear component (12 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain_YZ
  • full name: result.elastic_strain_YZ
  • internal name: EPELYZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_YZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_YZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPELYZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: interface contact mass (LSDyna)

Description

Read Interface Contact Mass (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
entity_scopingname
(scoping)expected type(s)

entity (part for matsum, interface for rcforc) where the result will be scoped

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: interface_contact_mass
  • full name: result.interface_contact_mass
  • internal name: R_CMass
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.interface_contact_mass() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.entity_scoping.Connect(my_entity_scoping)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.interface_contact_mass() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.entity_scoping.connect(my_entity_scoping)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("R_CMass"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_entity_scoping);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

invariant: eigen values (fields container)

Description

Computes the element-wise Eigen values of all the tensor fields of a fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: invariant
  • plugin: core
  • scripting name: eigen_values_fc
  • full name: invariant.eigen_values_fc
  • internal name: eig_values_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.eigen_values_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.eigen_values_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("eig_values_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain XZ

Description

Read/compute element nodal component elastic strains XZ shear component (02 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain_XZ
  • full name: result.elastic_strain_XZ
  • internal name: EPELXZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_XZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_XZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPELXZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

metadata: mesh property provider

Description

Reads a property related to the mesh, defined by its name, by calling the readers defined by the data sources. These properties can be used to fill in the mesh.

Supported file types

  • cff: flprj,cas
  • cgns: cgns
  • hdf5: h5dpf
  • lsdyna: d3plot
  • mapdl: rfrq,rdsp,rth,cms,rst,mode,dsub

Inputs

pin 1optional
mesh_scopingname
(scoping)expected type(s)

Retrieves a property field on a subset of elements or nodes.

pin 3optional
streams_containername
(streams_container)expected type(s)

streams (result file container) (optional)

pin 4requested
data_sourcesname
(data_sources)expected type(s)

If the stream is null, retrieves the file path from the data sources.

pin 13requested
property_namename
(string)expected type(s)

Supported property names are: "mat", "named_selection", "named_selection_names", "apdl_element_type", "section", "elprops", "keyopt_1" to "keyopt_18".

pin 17optional
property_identifiername
(int32 | string)expected type(s)

Retrieves a property at a given index or by name. For example, a named selection's number or a named selection's name.

Outputs

pin 0requested
propertyname
(scoping | property_field | string_field)expected type(s)

Returns a property field for properties: "mat", "apdl_element_type", "section", "elprops", "keyopt_1" to "keyopt_18" (or any mesh's property field), a scoping for properties:"named_selection", a string field for properties: "named_selection_names".

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: mesh_property_provider
  • full name: metadata.mesh_property_provider
  • internal name: mesh_property_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.mesh_property_provider() # operator instantiation
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.property_name.Connect(my_property_name)
op.inputs.property_identifier.Connect(my_property_identifier)
my_property = op.outputs.property.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.mesh_property_provider() # operator instantiation
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.property_name.connect(my_property_name)
op.inputs.property_identifier.connect(my_property_identifier)
my_property = op.outputs.property()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh_property_provider"); // operator instantiation
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(13, my_property_name);
op.connect(17, my_property_identifier);
ansys::dpf::Scoping my_property = op.getOutput<ansys::dpf::Scoping>(0);

result: rigid transformation

Description

Extracts rigid body motions from a displacement in input.

Supported file types

  • mapdl: dsub

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

streams (result file container) (optional)

pin 4requested
data_sourcesname
(data_sources)expected type(s)

If the stream is null, retrieves the file path from the data sources.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: rigid_transformation
  • full name: result.rigid_transformation
  • internal name: rigid_transformation_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.rigid_transformation() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.rigid_transformation() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("rigid_transformation_provider"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain principal 1

Description

Read/compute element nodal component elastic strains 1st principal component by calling the readers defined by the datasources and computing its eigen values. The off-diagonal strains are first converted from Voigt notation to the standard strain values.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain_principal_1
  • full name: result.elastic_strain_principal_1
  • internal name: EPEL1
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_principal_1() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_principal_1() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPEL1"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain principal 2

Description

Read/compute element nodal component elastic strains 2nd principal component by calling the readers defined by the datasources and computing its eigen values. The off-diagonal strains are first converted from Voigt notation to the standard strain values.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain_principal_2
  • full name: result.elastic_strain_principal_2
  • internal name: EPEL2
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_principal_2() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_principal_2() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPEL2"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

geo: scoping normals

Description

compute the normals at the given nodes or element scoping based on the given mesh (first version, the element normal is only handled on the shell elements)

Inputs

pin 0optional
meshname
(abstract_meshed_region)expected type(s)
pin 1optional
mesh_scopingname
(scoping)expected type(s)
pin 3optional
fieldname
(field)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: geo
  • plugin: core
  • scripting name: normals
  • full name: geo.normals
  • internal name: normals_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.normals() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.normals() # operator instantiation
op.inputs.mesh.connect(my_mesh)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("normals_provider"); // operator instantiation
op.connect(0, my_mesh);
op.connect(1, my_mesh_scoping);
op.connect(3, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: elastic strain principal 3

Description

Read/compute element nodal component elastic strains 3rd principal component by calling the readers defined by the datasources and computing its eigen values. The off-diagonal strains are first converted from Voigt notation to the standard strain values.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain_principal_3
  • full name: result.elastic_strain_principal_3
  • internal name: EPEL3
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_principal_3() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_principal_3() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPEL3"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: cyclic analytic disp max

Description

Compute the maximum of the total deformation that can be expected on 360 degrees

Inputs

pin 0optional
time_scopingname
(scoping | vector)expected type(s)
pin 1optional
mesh_scopingname
(scopings_container | scoping | vector)expected type(s)
pin 2requested
fields_containername
(fields_container)expected type(s)

field container with the base and duplicate sectors

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

default is true

pin 16requested
cyclic_supportname
(cyclic_support)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

FieldsContainer filled in

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.

Scripting

  • category: result
  • plugin: core
  • scripting name: cyclic_analytic_usum_max
  • full name: result.cyclic_analytic_usum_max
  • internal name: cyclic_analytic_usum_max
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.cyclic_analytic_usum_max() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.cyclic_support.Connect(my_cyclic_support)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.cyclic_analytic_usum_max() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container.connect(my_fields_container)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.cyclic_support.connect(my_cyclic_support)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("cyclic_analytic_usum_max"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container);
op.connect(5, my_bool_rotate_to_global);
op.connect(16, my_cyclic_support);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain eqv

Description

Read/compute element nodal equivalent elastic strain by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain_eqv
  • full name: result.elastic_strain_eqv
  • internal name: EPEL_EQV
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_eqv() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_eqv() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPEL_EQV"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: electric flux density X

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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: electric_flux_density_X
  • full name: result.electric_flux_density_X
  • internal name: EFDX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.electric_flux_density_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.electric_flux_density_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EFDX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain intensity

Description

Reads/computes element nodal component elastic strains, average it on nodes (by default) and computes its invariants.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain_intensity
  • full name: result.elastic_strain_intensity
  • internal name: EPEL_intensity
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_intensity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_intensity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPEL_intensity"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain max_shear

Description

Reads/computes element nodal component elastic strains, average it on nodes (by default) and computes its invariants.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain_max_shear
  • full name: result.elastic_strain_max_shear
  • internal name: EPEL_max_shear
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_max_shear() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_max_shear() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPEL_max_shear"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: turbulent dissipation rate (omega)

Description

Read Turbulent Specific Dissipation Rate (omega) by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: omega
  • full name: result.omega
  • internal name: OME
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.omega() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.omega() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("OME"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

averaging: to elemental (fields container)

Description

Transforms Input fields into Elemental fields using an averaging process. The result is computed on a given element's scoping.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
meshname
(abstract_meshed_region)expected type(s)
pin 3optional
mesh_scopingname
(scoping)expected type(s)
pin 7optional
smoothen_valuesname
(bool)expected type(s)

if it is set to true, Elemental Nodal fields are first averaged on nodes and then averaged on elements (default is false).

pin 10optional
collapse_shell_layersname
(bool)expected type(s)

If true, the data across different shell layers is averaged as well (default is false).

pin 26optional
merge_solid_shellname
(bool)expected type(s)

For shell/solid mixed fields, group in the same field all solids and shells (false by default). If this pin is true and collapse_shell_layers is false, a shell_layer needs to be specified.

pin 27optional
shell_layername
(int32)expected type(s)

0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid. If merge_solid_shell is true, this pin needs to be specified to a value that extracts only one layer (Top, Bottom or Mid).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: to_elemental_fc
  • full name: averaging.to_elemental_fc
  • internal name: to_elemental_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.to_elemental_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.smoothen_values.Connect(my_smoothen_values)
op.inputs.collapse_shell_layers.Connect(my_collapse_shell_layers)
op.inputs.merge_solid_shell.Connect(my_merge_solid_shell)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.to_elemental_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.smoothen_values.connect(my_smoothen_values)
op.inputs.collapse_shell_layers.connect(my_collapse_shell_layers)
op.inputs.merge_solid_shell.connect(my_merge_solid_shell)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("to_elemental_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(3, my_mesh_scoping);
op.connect(7, my_smoothen_values);
op.connect(10, my_collapse_shell_layers);
op.connect(26, my_merge_solid_shell);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: plastic strain

Description

Read/compute element nodal component plastic strains by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain
  • full name: result.plastic_strain
  • internal name: EPPL
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPPL"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

scoping: transpose

Description

Transposes the input scoping or scopings container (Elemental/Faces --> Nodal, or Nodal ---> Elemental/Faces), based on the input mesh region.

Inputs

pin 0requested
mesh_scopingname
(scoping | scopings_container)expected type(s)

Scoping or scopings container (the input type is the output type)

pin 1requested
meshed_regionname
(meshed_region | meshes_container)expected type(s)
pin 2optional
inclusivename
(int32)expected type(s)

if inclusive == 1 then all the elements/faces adjacent to the nodes/faces ids in input are added, if inclusive == 0, only the elements/faces which have all their nodes/faces in the scoping are included

pin 9optional
requested_locationname
(string)expected type(s)

Output scoping location for meshes with nodes, faces and elements. By default, elemental and faces scopings transpose to nodal, and nodal scopings transpose to elemental.

Outputs

pin 0requested
mesh_scopingname
(scoping | scopings_container)expected type(s)

Scoping or scopings container (the input type is the output type)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: transpose
  • full name: scoping.transpose
  • internal name: transpose_scoping
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.transpose() # operator instantiation
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.meshed_region.Connect(my_meshed_region)
op.inputs.inclusive.Connect(my_inclusive)
op.inputs.requested_location.Connect(my_requested_location)
my_mesh_scoping = op.outputs.mesh_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.transpose() # operator instantiation
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.meshed_region.connect(my_meshed_region)
op.inputs.inclusive.connect(my_inclusive)
op.inputs.requested_location.connect(my_requested_location)
my_mesh_scoping = op.outputs.mesh_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("transpose_scoping"); // operator instantiation
op.connect(0, my_mesh_scoping);
op.connect(1, my_meshed_region);
op.connect(2, my_inclusive);
op.connect(9, my_requested_location);
ansys::dpf::Scoping my_mesh_scoping = op.getOutput<ansys::dpf::Scoping>(0);

result: plastic strain X

Description

Read/compute element nodal component plastic strains XX normal component (00 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain_X
  • full name: result.plastic_strain_X
  • internal name: EPPLX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPPLX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: mass fraction

Description

Read Mass Fraction by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: mass_fraction
  • full name: result.mass_fraction
  • internal name: Y
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mass_fraction() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mass_fraction() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("Y"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: plastic strain Y

Description

Read/compute element nodal component plastic strains YY normal component (11 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain_Y
  • full name: result.plastic_strain_Y
  • internal name: EPPLY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPPLY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: coordinates (LSDyna)

Description

Read/compute Coordinates (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: coordinates
  • full name: result.coordinates
  • internal name: X
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.coordinates() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.coordinates() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("X"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

geo: to polar coordinates

Description

Finds r, theta (rad), and z coordinates of a coordinates (nodal) field in a cartesian coordinates system where the input coordinate system defines the rotation axis and the origin.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
coordinate_systemname
(field)expected type(s)

3-3 rotation matrix and origin coordinates must be set here to define a coordinate system. By default, the rotation axis is the z axis and the origin is [0,0,0].

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: geo
  • plugin: core
  • scripting name: to_polar_coordinates
  • full name: geo.to_polar_coordinates
  • internal name: polar_coordinates
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.to_polar_coordinates() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.coordinate_system.Connect(my_coordinate_system)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.to_polar_coordinates() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.coordinate_system.connect(my_coordinate_system)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("polar_coordinates"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_coordinate_system);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

filter: band pass (fields container)

Description

The band pass filter returns all the values above (but not equal to) the minimum threshold value and below (but not equal to) the maximum threshold value in input.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
min_thresholdname
(double | field)expected type(s)

A minimum threshold scalar or a field containing one value is expected.

pin 2optional
max_thresholdname
(double | field)expected type(s)

A maximum threshold scalar or a field containing one value is expected.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: field_band_pass_fc
  • full name: filter.field_band_pass_fc
  • internal name: core::field::band_pass_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.field_band_pass_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.min_threshold.Connect(my_min_threshold)
op.inputs.max_threshold.Connect(my_max_threshold)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.field_band_pass_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.min_threshold.connect(my_min_threshold)
op.inputs.max_threshold.connect(my_max_threshold)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("core::field::band_pass_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_min_threshold);
op.connect(2, my_max_threshold);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: fft evaluation

Description

Evaluate the fast fourier transforms at a given set of fields.

Inputs

pin 0requested
field_tname
(field)expected type(s)

field of values to evaluate

pin 1optional
time_scopingname
(scoping)expected type(s)

if specified only the results at these set ids are used

Outputs

pin 0requested
fieldname
(field)expected type(s)
pin 2requested
offsetname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: fft_eval
  • full name: math.fft_eval
  • internal name: fft_eval
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.fft_eval() # operator instantiation
op.inputs.field_t.Connect(my_field_t)
op.inputs.time_scoping.Connect(my_time_scoping)
my_field = op.outputs.field.GetData()
my_offset = op.outputs.offset.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.fft_eval() # operator instantiation
op.inputs.field_t.connect(my_field_t)
op.inputs.time_scoping.connect(my_time_scoping)
my_field = op.outputs.field()
my_offset = op.outputs.offset()
#include "dpf_api.h"

ansys::dpf::Operator op("fft_eval"); // operator instantiation
op.connect(0, my_field_t);
op.connect(1, my_time_scoping);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_offset = op.getOutput<ansys::dpf::Field>(2);

result: global total energy (LSDyna)

Description

Read Global Total Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout,d3plot

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_total_energy
  • full name: result.global_total_energy
  • internal name: GLOB_ENG_TE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_total_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_total_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_ENG_TE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: plastic strain Z

Description

Read/compute element nodal component plastic strains ZZ normal component (22 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain_Z
  • full name: result.plastic_strain_Z
  • internal name: EPPLZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPPLZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: merge materials

Description

Assembles a set of materials into a unique one.

Inputs

pin 0, 1...requested, ellipsis
materialsname
(vector> | materials)expected type(s)

A vector of materials to merge or materials from pin 0 to ...

Outputs

pin 0requested
merged_materialsname
(materials)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_materials
  • full name: utility.merge_materials
  • internal name: merge::materials
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_materials() # operator instantiation
op.inputs.materials1.Connect(my_materials_1)
op.inputs.materials2.Connect(my_materials_2)
my_merged_materials = op.outputs.merged_materials.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_materials() # operator instantiation
op.inputs.materials1.connect(my_materials_1)
op.inputs.materials2.connect(my_materials_2)
my_merged_materials = op.outputs.merged_materials()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::materials"); // operator instantiation
op.connect(0, my_materials_1);
op.connect(1, my_materials_2);
ansys::dpf::Materials my_merged_materials = op.getOutput<ansys::dpf::Materials>(0);

result: dynamic viscosity

Description

Read Dynamic Viscosity by calling the readers defined by the datasources.

Supported file types

  • cff: flprj,cas

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: dynamic_viscosity
  • full name: result.dynamic_viscosity
  • internal name: MU
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.dynamic_viscosity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.dynamic_viscosity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MU"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: vtk export

Description

Write the input field and fields container into a given vtk path

Inputs

pin -1optional
export_typename
(int32)expected type(s)

Either export volume elements in the mesh with their fields with value 0 or faces elements in the mesh with their fields with value 1 (default is 0)

pin 0requested
file_pathname
(string)expected type(s)

path with vtk extension were the export occurs

pin 1optional
meshname
(abstract_meshed_region)expected type(s)

necessary if the first field or fields container don't have a mesh in their support

pin 2, 3...requested, ellipsis
fieldsname
(fields_container | field)expected type(s)

fields exported

Outputs

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: vtk
  • scripting name: vtk_export
  • full name: serialization.vtk_export
  • internal name: vtk_export
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.vtk_export() # operator instantiation
op.inputs.export_type.Connect(my_export_type)
op.inputs.file_path.Connect(my_file_path)
op.inputs.mesh.Connect(my_mesh)
op.inputs.fields1.Connect(my_fields_1)
op.inputs.fields2.Connect(my_fields_2)
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.vtk_export() # operator instantiation
op.inputs.export_type.connect(my_export_type)
op.inputs.file_path.connect(my_file_path)
op.inputs.mesh.connect(my_mesh)
op.inputs.fields1.connect(my_fields_1)
op.inputs.fields2.connect(my_fields_2)
#include "dpf_api.h"

ansys::dpf::Operator op("vtk_export"); // operator instantiation
op.connect(-1, my_export_type);
op.connect(0, my_file_path);
op.connect(1, my_mesh);
op.connect(2, my_fields_1);
op.connect(3, my_fields_2);

result: plastic strain XY

Description

Read/compute element nodal component plastic strains XY shear component (01 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain_XY
  • full name: result.plastic_strain_XY
  • internal name: EPPLXY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_XY() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_XY() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPPLXY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: hydrostatic pressure

Description

Read/compute element nodal hydrostatic pressure by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: hydrostatic_pressure
  • full name: result.hydrostatic_pressure
  • internal name: ENL_HPRES
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.hydrostatic_pressure() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.hydrostatic_pressure() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENL_HPRES"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute stress von mises

Description

Computes the stress from an elastic strain field. compute_total_strain limitations are applicable for stress computationGet the Von Mises equivalent stress.

Inputs

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Needed to get mesh and material ids. Optional if a data_sources have been connected.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

Needed to get mesh and material ids. Optional if a streams_container have been connected.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10requested
strainname
(fields_container | field)expected type(s)

Field/or fields container containing only the elastic strain field (element nodal).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_stress_von_mises
  • full name: result.compute_stress_von_mises
  • internal name: compute_stress_von_mises
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_stress_von_mises() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.strain.Connect(my_strain)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_stress_von_mises() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.strain.connect(my_strain)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_stress_von_mises"); // operator instantiation
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(9, my_requested_location);
op.connect(10, my_strain);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

filter: low pass (scoping)

Description

The low pass filter returns all the values below (but not equal to) the threshold value in input.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
thresholdname
(double | field)expected type(s)

a threshold scalar or a field containing one value is expected

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: scoping_low_pass
  • full name: filter.scoping_low_pass
  • internal name: core::scoping::low_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.scoping_low_pass() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.scoping_low_pass() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("core::scoping::low_pass"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(0);

result: plastic strain YZ

Description

Read/compute element nodal component plastic strains YZ shear component (12 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain_YZ
  • full name: result.plastic_strain_YZ
  • internal name: EPPLYZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_YZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_YZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPPLYZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

mesh: iso surfaces

Description

Extract multiple iso-contours from mesh_cut operator and set it into a meshes container. If pin 1 is provided, "num_surfaces" iso-contours will be computed, ranging from "min_value" to "max_value" linearly. If pin 4 is provided, the iso-values are the one set by the user. The iso-values are stored into a FieldsContainer.

Inputs

pin 0requested
fieldname
(field)expected type(s)

Field containing the values for the iso-surface computation. The mesh can be retrieved from this field's support or through pin 2.

pin 1optional
num_surfacesname
(int32)expected type(s)

If provided, iso_values are linearly computed between the min and the max of the field of results. If not, iso_values must be provided by the user through pin 4

pin 2optional
meshname
(meshed_region)expected type(s)

Mesh to compute the iso-surface from. Used when not given through the support of the field in pin 0.

pin 3requested
slice_surfacesname
(bool)expected type(s)

True: slicing will also take into account shell and skin elements. False: slicing will ignore shell and skin elements. The default is true.

pin 4optional
vector_iso_valuesname
(vector)expected type(s)

If provided, user defined iso_values to compute. If not provided, iso_values are linearly compute between the min and the max of the field of results.

Outputs

pin 0requested
meshesname
(meshes_container)expected type(s)
pin 1requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: iso_surfaces
  • full name: mesh.iso_surfaces
  • internal name: iso_surfaces
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.iso_surfaces() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.num_surfaces.Connect(my_num_surfaces)
op.inputs.mesh.Connect(my_mesh)
op.inputs.slice_surfaces.Connect(my_slice_surfaces)
op.inputs.vector_iso_values.Connect(my_vector_iso_values)
my_meshes = op.outputs.meshes.GetData()
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.iso_surfaces() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.num_surfaces.connect(my_num_surfaces)
op.inputs.mesh.connect(my_mesh)
op.inputs.slice_surfaces.connect(my_slice_surfaces)
op.inputs.vector_iso_values.connect(my_vector_iso_values)
my_meshes = op.outputs.meshes()
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("iso_surfaces"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_num_surfaces);
op.connect(2, my_mesh);
op.connect(3, my_slice_surfaces);
op.connect(4, my_vector_iso_values);
ansys::dpf::MeshesContainer my_meshes = op.getOutput<ansys::dpf::MeshesContainer>(0);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(1);

result: plastic strain XZ

Description

Read/compute element nodal component plastic strains XZ shear component (02 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain_XZ
  • full name: result.plastic_strain_XZ
  • internal name: EPPLXZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_XZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_XZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPPLXZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: workflow energy per harmonic

Description

Calculates the cumulated energy per harmonic in a multistage multiharmonic model.

Inputs

pin 0optional
time_scopingname
(scoping)expected type(s)
pin 1optional
mesh_scopingname
(scoping)expected type(s)

Master scoping. All harmonics will be intersected with this scoping.

pin 2optional
energy_typename
(int32)expected type(s)

Type of energy to be processed: (0: Strain + Kinetic energy (default), 1: Strain energy, 2: Kinetic energy)

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
harmonic_energyname
(fields_container)expected type(s)
pin 1requested
harmonic_energy_percentagename
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: workflow_energy_per_harmonic
  • full name: result.workflow_energy_per_harmonic
  • internal name: workflow_energy_per_harmonic
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.workflow_energy_per_harmonic() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.energy_type.Connect(my_energy_type)
op.inputs.data_sources.Connect(my_data_sources)
my_harmonic_energy = op.outputs.harmonic_energy.GetData()
my_harmonic_energy_percentage = op.outputs.harmonic_energy_percentage.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.workflow_energy_per_harmonic() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.energy_type.connect(my_energy_type)
op.inputs.data_sources.connect(my_data_sources)
my_harmonic_energy = op.outputs.harmonic_energy()
my_harmonic_energy_percentage = op.outputs.harmonic_energy_percentage()
#include "dpf_api.h"

ansys::dpf::Operator op("workflow_energy_per_harmonic"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_energy_type);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_harmonic_energy = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_harmonic_energy_percentage = op.getOutput<ansys::dpf::FieldsContainer>(1);

result: plastic strain principal 3

Description

Read/compute element nodal component plastic strains 3rd principal component by calling the readers defined by the datasources and computing its eigen values. The off-diagonal strains are first converted from Voigt notation to the standard strain values.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain_principal_3
  • full name: result.plastic_strain_principal_3
  • internal name: EPPL3
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_principal_3() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_principal_3() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPPL3"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: plastic strain intensity

Description

Reads/computes element nodal component plastic strains, average it on nodes (by default) and computes its invariants.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain_intensity
  • full name: result.plastic_strain_intensity
  • internal name: EPPL_intensity
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_intensity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_intensity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPPL_intensity"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

filter: band pass (field)

Description

The band pass filter returns all the values above (but not equal to) the minimum threshold value and below (but not equal to) the maximum threshold value in input.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
min_thresholdname
(double | field)expected type(s)

A minimum threshold scalar or a field containing one value is expected.

pin 2optional
max_thresholdname
(double | field)expected type(s)

A maximum threshold scalar or a field containing one value is expected.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: field_band_pass
  • full name: filter.field_band_pass
  • internal name: core::field::band_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.field_band_pass() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.min_threshold.Connect(my_min_threshold)
op.inputs.max_threshold.Connect(my_max_threshold)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.field_band_pass() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.min_threshold.connect(my_min_threshold)
op.inputs.max_threshold.connect(my_max_threshold)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("core::field::band_pass"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_min_threshold);
op.connect(2, my_max_threshold);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

filter: low pass (timefreq)

Description

The low pass filter returns all the values below (but not equal to) the threshold value in input.

Inputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1requested
thresholdname
(double | field)expected type(s)

a threshold scalar or a field containing one value is expected

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: timefreq_low_pass
  • full name: filter.timefreq_low_pass
  • internal name: core::timefreq::low_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.timefreq_low_pass() # operator instantiation
op.inputs.time_freq_support.Connect(my_time_freq_support)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_time_freq_support = op.outputs.time_freq_support.GetData()
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.timefreq_low_pass() # operator instantiation
op.inputs.time_freq_support.connect(my_time_freq_support)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_time_freq_support = op.outputs.time_freq_support()
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("core::timefreq::low_pass"); // operator instantiation
op.connect(0, my_time_freq_support);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::TimeFreqSupport my_time_freq_support = op.getOutput<ansys::dpf::TimeFreqSupport>(0);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(1);

result: plastic strain max_shear

Description

Reads/computes element nodal component plastic strains, average it on nodes (by default) and computes its invariants.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain_max_shear
  • full name: result.plastic_strain_max_shear
  • internal name: EPPL_max_shear
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_max_shear() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_max_shear() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPPL_max_shear"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: creep strain

Description

Read/compute element nodal component creep strains by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain
  • full name: result.creep_strain
  • internal name: EPCR
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPCR"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: vtu export

Description

Export DPF data into vtu format.

Inputs

pin 0requested
directoryname
(string)expected type(s)

directory path

pin 1optional
base_namename
(string)expected type(s)

vtu base file name, (default is file)

pin 2requested
meshname
(abstract_meshed_region)expected type(s)

mesh

pin 3, 4...requested, ellipsis
fieldsname
(field | fields_container | property_field)expected type(s)

Nodal, Face, or Elemental field, fields container (over time), or property field to export. When there is no support available in the exported mesh, that data is ignored.

pin 100optional
write_modename
(string)expected type(s)

Available are rawbinarycompressed, rawbinary, base64appended, base64inline, ascii, default is (rawbinarycompressed)

pin 101optional
as_point_cloudname
(bool)expected type(s)

Whether to export the mesh as a point cloud. Default is False.

pin 102optional
export_facesname
(bool)expected type(s)

Whether to also export faces as shell elements when the mesh contains cells. Default is False.

pin 103optional
mesh_propertiesname
(vector | string_field)expected type(s)

List of names of mesh properties to export.

Outputs

pin 0requested
pathname
(data_sources)expected type(s)

list of output vtu file path

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.

Scripting

  • category: serialization
  • plugin: vtk
  • scripting name: vtu_export
  • full name: serialization.vtu_export
  • internal name: vtu_export
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.vtu_export() # operator instantiation
op.inputs.directory.Connect(my_directory)
op.inputs.base_name.Connect(my_base_name)
op.inputs.mesh.Connect(my_mesh)
op.inputs.fields1.Connect(my_fields_1)
op.inputs.fields2.Connect(my_fields_2)
op.inputs.write_mode.Connect(my_write_mode)
op.inputs.as_point_cloud.Connect(my_as_point_cloud)
op.inputs.export_faces.Connect(my_export_faces)
op.inputs.mesh_properties.Connect(my_mesh_properties)
my_path = op.outputs.path.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.vtu_export() # operator instantiation
op.inputs.directory.connect(my_directory)
op.inputs.base_name.connect(my_base_name)
op.inputs.mesh.connect(my_mesh)
op.inputs.fields1.connect(my_fields_1)
op.inputs.fields2.connect(my_fields_2)
op.inputs.write_mode.connect(my_write_mode)
op.inputs.as_point_cloud.connect(my_as_point_cloud)
op.inputs.export_faces.connect(my_export_faces)
op.inputs.mesh_properties.connect(my_mesh_properties)
my_path = op.outputs.path()
#include "dpf_api.h"

ansys::dpf::Operator op("vtu_export"); // operator instantiation
op.connect(0, my_directory);
op.connect(1, my_base_name);
op.connect(2, my_mesh);
op.connect(3, my_fields_1);
op.connect(4, my_fields_2);
op.connect(100, my_write_mode);
op.connect(101, my_as_point_cloud);
op.connect(102, my_export_faces);
op.connect(103, my_mesh_properties);
ansys::dpf::DataSources my_path = op.getOutput<ansys::dpf::DataSources>(0);

result: creep strain Y

Description

Read/compute element nodal component creep strains YY normal component (11 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain_Y
  • full name: result.creep_strain_Y
  • internal name: EPCRY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPCRY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

filter: high pass (fields container)

Description

The high pass filter returns all the values above (but not equal to) the threshold value in input.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
thresholdname
(double | field)expected type(s)

A threshold scalar or a field containing one value is expected.

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: field_high_pass_fc
  • full name: filter.field_high_pass_fc
  • internal name: core::field::high_pass_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.field_high_pass_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.field_high_pass_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("core::field::high_pass_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: serializer to string

Description

Take any input and serialize them in a string.

Inputs

pin -1requested
stream_typename
(int32)expected type(s)

0 for string (default), 1 for binary, 2 for binary with chunked output (the output string will be returned in several chunks to prevent string memory overflows).

pin 1, 2...requested, ellipsis
any_inputname
(any)expected type(s)

any input

Outputs

pin -1requested
nof_chunksname
(int32)expected type(s)

Number of chunks when mode passed to input pin(-1) = 2.

pin 0, 1...requested, ellipsis
serialized_stringname
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: serializer_to_string
  • full name: serialization.serializer_to_string
  • internal name: serializer_to_string
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.serializer_to_string() # operator instantiation
op.inputs.stream_type.Connect(my_stream_type)
op.inputs.any_input1.Connect(my_any_input_1)
op.inputs.any_input2.Connect(my_any_input_2)
my_nof_chunks = op.outputs.nof_chunks.GetData()
my_serialized_string = op.outputs.serialized_string.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.serializer_to_string() # operator instantiation
op.inputs.stream_type.connect(my_stream_type)
op.inputs.any_input1.connect(my_any_input_1)
op.inputs.any_input2.connect(my_any_input_2)
my_nof_chunks = op.outputs.nof_chunks()
my_serialized_string = op.outputs.serialized_string()
#include "dpf_api.h"

ansys::dpf::Operator op("serializer_to_string"); // operator instantiation
op.connect(-1, my_stream_type);
op.connect(1, my_any_input_1);
op.connect(2, my_any_input_2);
int my_nof_chunks = op.getOutput<int>(-1);
std::string my_serialized_string = op.getOutput<std::string>(0);

result: creep strain Z

Description

Read/compute element nodal component creep strains ZZ normal component (22 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain_Z
  • full name: result.creep_strain_Z
  • internal name: EPCRZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPCRZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: creep strain XY

Description

Read/compute element nodal component creep strains XY shear component (01 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain_XY
  • full name: result.creep_strain_XY
  • internal name: EPCRXY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain_XY() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain_XY() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPCRXY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: stress solution to global cs

Description

read Euler angles on elements from the result file and rotate the fields in the fieldsContainer.

Inputs

pin 2optional
fields_containername
(fields_container)expected type(s)
pin 3optional
streams_containername
(streams_container | stream | class dataProcessing::CRstFileWrapper)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: stress_rotation_by_euler_nodes
  • full name: result.stress_rotation_by_euler_nodes
  • internal name: mapdl::rst::S_rotation_by_euler_nodes
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_rotation_by_euler_nodes() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_rotation_by_euler_nodes() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("mapdl::rst::S_rotation_by_euler_nodes"); // operator instantiation
op.connect(2, my_fields_container);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: contact pressure

Description

Read/compute element contact pressure by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: contact_pressure
  • full name: result.contact_pressure
  • internal name: ECT_PRES
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.contact_pressure() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.contact_pressure() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ECT_PRES"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: creep strain YZ

Description

Read/compute element nodal component creep strains YZ shear component (12 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain_YZ
  • full name: result.creep_strain_YZ
  • internal name: EPCRYZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain_YZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain_YZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPCRYZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: creep strain XZ

Description

Read/compute element nodal component creep strains XZ shear component (02 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain_XZ
  • full name: result.creep_strain_XZ
  • internal name: EPCRXZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain_XZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain_XZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPCRXZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: creep strain principal 2

Description

Read/compute element nodal component creep strains 2nd principal component by calling the readers defined by the datasources and computing its eigen values. The off-diagonal strains are first converted from Voigt notation to the standard strain values.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain_principal_2
  • full name: result.creep_strain_principal_2
  • internal name: EPCR2
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain_principal_2() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain_principal_2() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPCR2"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elemental volume

Description

Read/compute element volume by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • mapdl: cms,rst,mode,dsub,rth,rfrq,rdsp

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elemental_volume
  • full name: result.elemental_volume
  • internal name: ENG_VOL
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elemental_volume() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elemental_volume() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENG_VOL"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

logic: same string fields?

Description

Takes two string fields and compares them.

Inputs

pin 0requested
string_fieldAname
(string_field)expected type(s)
pin 1requested
string_fieldBname
(string_field)expected type(s)

Outputs

pin 0requested
are_identicalname
(bool)expected type(s)
pin 1requested
informationname
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: identical_string_fields
  • full name: logic.identical_string_fields
  • internal name: compare::string_field
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.identical_string_fields() # operator instantiation
op.inputs.string_fieldA.Connect(my_string_fieldA)
op.inputs.string_fieldB.Connect(my_string_fieldB)
my_are_identical = op.outputs.are_identical.GetData()
my_information = op.outputs.information.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.identical_string_fields() # operator instantiation
op.inputs.string_fieldA.connect(my_string_fieldA)
op.inputs.string_fieldB.connect(my_string_fieldB)
my_are_identical = op.outputs.are_identical()
my_information = op.outputs.information()
#include "dpf_api.h"

ansys::dpf::Operator op("compare::string_field"); // operator instantiation
op.connect(0, my_string_fieldA);
op.connect(1, my_string_fieldB);
bool my_are_identical = op.getOutput<bool>(0);
std::string my_information = op.getOutput<std::string>(1);

result: creep strain principal 3

Description

Read/compute element nodal component creep strains 3rd principal component by calling the readers defined by the datasources and computing its eigen values. The off-diagonal strains are first converted from Voigt notation to the standard strain values.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain_principal_3
  • full name: result.creep_strain_principal_3
  • internal name: EPCR3
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain_principal_3() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain_principal_3() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPCR3"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: creep strain intensity

Description

Reads/computes element nodal component creep strains, average it on nodes (by default) and computes its invariants.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain_intensity
  • full name: result.creep_strain_intensity
  • internal name: EPCR_intensity
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain_intensity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain_intensity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPCR_intensity"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

averaging: elemental to elemental nodal (field)

Description

Transforms an Elemental field to an Elemental Nodal field.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
mesh_scopingname
(scoping)expected type(s)

average only on these entities

pin 7optional
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: elemental_to_elemental_nodal
  • full name: averaging.elemental_to_elemental_nodal
  • internal name: elemental_to_elemental_nodal
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.elemental_to_elemental_nodal() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.mesh.Connect(my_mesh)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.elemental_to_elemental_nodal() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.mesh.connect(my_mesh)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("elemental_to_elemental_nodal"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_mesh_scoping);
op.connect(7, my_mesh);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: thermal strain X

Description

Read/compute element nodal component thermal strains XX normal component (00 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: thermal_strain_X
  • full name: result.thermal_strain_X
  • internal name: ETHX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thermal_strain_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thermal_strain_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ETHX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: thermal strain Y

Description

Read/compute element nodal component thermal strains YY normal component (11 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: thermal_strain_Y
  • full name: result.thermal_strain_Y
  • internal name: ETHY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thermal_strain_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thermal_strain_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ETHY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: equivalent radiated power

Description

Compute the Equivalent Radiated Power (ERP)

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

the input field container expects displacements fields

pin 1requested
meshname
(abstract_meshed_region | meshes_container)expected type(s)

the mesh region in this pin has to be boundary or skin mesh

pin 2requested
time_scopingname
(int32 | vector | scoping)expected type(s)

load step number (if it's specified, the ERP is computed only on the substeps of this step) or time scoping

pin 3requested
mass_densityname
(double)expected type(s)

mass density (if it's not specified, default value of the air is applied).

pin 4requested
speed_of_soundname
(double)expected type(s)

speed of sound (if it's not specified, default value of the speed of sound in the air is applied).

pin 5requested
erp_typename
(int32)expected type(s)

if this pin is set to 0, the classical ERP is computed, 1 the corrected ERP is computed (a mesh of one face has to be given in the pin 1) and 2 the enhanced ERP is computed. Default is 0.

pin 6requested
booleanname
(bool)expected type(s)

if this pin is set to true, the ERP level in dB is computed

pin 7requested
factorname
(double)expected type(s)

erp reference value. Default is 1E-12

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: equivalent_radiated_power
  • full name: result.equivalent_radiated_power
  • internal name: ERP
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.equivalent_radiated_power() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mass_density.Connect(my_mass_density)
op.inputs.speed_of_sound.Connect(my_speed_of_sound)
op.inputs.erp_type.Connect(my_erp_type)
op.inputs.boolean.Connect(my_boolean)
op.inputs.factor.Connect(my_factor)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.equivalent_radiated_power() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mass_density.connect(my_mass_density)
op.inputs.speed_of_sound.connect(my_speed_of_sound)
op.inputs.erp_type.connect(my_erp_type)
op.inputs.boolean.connect(my_boolean)
op.inputs.factor.connect(my_factor)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ERP"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(2, my_time_scoping);
op.connect(3, my_mass_density);
op.connect(4, my_speed_of_sound);
op.connect(5, my_erp_type);
op.connect(6, my_boolean);
op.connect(7, my_factor);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: thermal strain Z

Description

Read/compute element nodal component thermal strains ZZ normal component (22 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: thermal_strain_Z
  • full name: result.thermal_strain_Z
  • internal name: ETHZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thermal_strain_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thermal_strain_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ETHZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: accumulate over label

Description

Compute the component-wise sum over all the fields that have the same ID as the label set as input in the fields container. This computation can be incremental. If the input fields container is connected and the operator is run multiple times, the output field will be on all the connected inputs.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
labelname
(string)expected type(s)

Label of the fields container where it should operate.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

incrementalThis operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
(bool)expected type(s)
truedefault value
: This operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: accumulate_over_label_fc
  • full name: math.accumulate_over_label_fc
  • internal name: accumulate_over_label_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.accumulate_over_label_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.label.Connect(my_label)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.accumulate_over_label_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.label.connect(my_label)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("accumulate_over_label_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_label);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: merge scopings containers

Description

Assembles a set of scopings containers into a unique one.

Inputs

pin 0, 1...requested, ellipsis
scopings_containersname
(vector> | scopings_container)expected type(s)

A vector of scopings containers to merge or scopings containers from pin 0 to ...

Outputs

pin 0requested
merged_scopings_containername
(scopings_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_scopings_containers
  • full name: utility.merge_scopings_containers
  • internal name: merge::scopings_container
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_scopings_containers() # operator instantiation
op.inputs.scopings_containers1.Connect(my_scopings_containers_1)
op.inputs.scopings_containers2.Connect(my_scopings_containers_2)
my_merged_scopings_container = op.outputs.merged_scopings_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_scopings_containers() # operator instantiation
op.inputs.scopings_containers1.connect(my_scopings_containers_1)
op.inputs.scopings_containers2.connect(my_scopings_containers_2)
my_merged_scopings_container = op.outputs.merged_scopings_container()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::scopings_container"); // operator instantiation
op.connect(0, my_scopings_containers_1);
op.connect(1, my_scopings_containers_2);
ansys::dpf::ScopingsContainer my_merged_scopings_container = op.getOutput<ansys::dpf::ScopingsContainer>(0);

result: thermal strain XY

Description

Read/compute element nodal component thermal strains XY shear component (01 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: thermal_strain_XY
  • full name: result.thermal_strain_XY
  • internal name: ETHXY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thermal_strain_XY() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thermal_strain_XY() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ETHXY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: thermal strain YZ

Description

Read/compute element nodal component thermal strains YZ shear component (12 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: thermal_strain_YZ
  • full name: result.thermal_strain_YZ
  • internal name: ETHYZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thermal_strain_YZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thermal_strain_YZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ETHYZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: thermal strain principal 1

Description

Read/compute element nodal component thermal strains 1st principal component by calling the readers defined by the datasources and computing its eigen values. The off-diagonal strains are first converted from Voigt notation to the standard strain values.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: thermal_strain_principal_1
  • full name: result.thermal_strain_principal_1
  • internal name: ETH1
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thermal_strain_principal_1() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thermal_strain_principal_1() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ETH1"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

logic: same anys?

Description

Takes two Any objects and compares them.Supported types: Field, FieldsContainer, Mesh, MeshesContainer, PropertyField, PropertyFieldsContainer, Scoping, ScopingsContainer, StringField, standard types (double, int, string, vector of int, doubles, string). Note: all inputs related to fields, mesh, and so on are passed to each property check.

Inputs

pin 0requested
anyAname
(any)expected type(s)
pin 1requested
anyBname
(any)expected type(s)
pin 2requested
double_valuename
(double)expected type(s)

Double positive small value. Smallest value considered during the comparison step. All the absolute values in the field less than this value are considered null, (default value: 1.0e-14).

pin 3optional
double_tolerancename
(double)expected type(s)

Double relative tolerance. Maximum tolerance gap between two compared values. Values within relative tolerance are considered identical. Formula is (v1-v2)/v2 < relativeTol. Default is 0.001.

pin 4requested
compare_auxiliaryname
(bool)expected type(s)

For meshes and meshescontainer: compare auxiliary data (i.e property fields, scopings...). Default value is 'false'.

Outputs

pin 0requested
includedname
(bool)expected type(s)

bool (true if belongs...)

pin 1requested
messagename
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: identical_anys
  • full name: logic.identical_anys
  • internal name: compare::any
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.identical_anys() # operator instantiation
op.inputs.anyA.Connect(my_anyA)
op.inputs.anyB.Connect(my_anyB)
op.inputs.double_value.Connect(my_double_value)
op.inputs.double_tolerance.Connect(my_double_tolerance)
op.inputs.compare_auxiliary.Connect(my_compare_auxiliary)
my_included = op.outputs.included.GetData()
my_message = op.outputs.message.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.identical_anys() # operator instantiation
op.inputs.anyA.connect(my_anyA)
op.inputs.anyB.connect(my_anyB)
op.inputs.double_value.connect(my_double_value)
op.inputs.double_tolerance.connect(my_double_tolerance)
op.inputs.compare_auxiliary.connect(my_compare_auxiliary)
my_included = op.outputs.included()
my_message = op.outputs.message()
#include "dpf_api.h"

ansys::dpf::Operator op("compare::any"); // operator instantiation
op.connect(0, my_anyA);
op.connect(1, my_anyB);
op.connect(2, my_double_value);
op.connect(3, my_double_tolerance);
op.connect(4, my_compare_auxiliary);
bool my_included = op.getOutput<bool>(0);
std::string my_message = op.getOutput<std::string>(1);

result: thermal strain principal 2

Description

Read/compute element nodal component thermal strains 2nd principal component by calling the readers defined by the datasources and computing its eigen values. The off-diagonal strains are first converted from Voigt notation to the standard strain values.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: thermal_strain_principal_2
  • full name: result.thermal_strain_principal_2
  • internal name: ETH2
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thermal_strain_principal_2() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thermal_strain_principal_2() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ETH2"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: thermal strain principal 3

Description

Read/compute element nodal component thermal strains 3rd principal component by calling the readers defined by the datasources and computing its eigen values. The off-diagonal strains are first converted from Voigt notation to the standard strain values.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)
pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: thermal_strain_principal_3
  • full name: result.thermal_strain_principal_3
  • internal name: ETH3
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thermal_strain_principal_3() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thermal_strain_principal_3() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ETH3"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: serializer

Description

Take any input and serialize them in a file.

Inputs

pin -1requested
stream_typename
(int32)expected type(s)

0 for ASCII (default), and 1 for binary

pin 0requested
file_pathname
(string)expected type(s)
pin 1, 2...requested, ellipsis
any_inputname
(any)expected type(s)

any input

Outputs

pin 0requested
file_pathname
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: serializer
  • full name: serialization.serializer
  • internal name: serializer
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.serializer() # operator instantiation
op.inputs.stream_type.Connect(my_stream_type)
op.inputs.file_path.Connect(my_file_path)
op.inputs.any_input1.Connect(my_any_input_1)
op.inputs.any_input2.Connect(my_any_input_2)
my_file_path = op.outputs.file_path.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.serializer() # operator instantiation
op.inputs.stream_type.connect(my_stream_type)
op.inputs.file_path.connect(my_file_path)
op.inputs.any_input1.connect(my_any_input_1)
op.inputs.any_input2.connect(my_any_input_2)
my_file_path = op.outputs.file_path()
#include "dpf_api.h"

ansys::dpf::Operator op("serializer"); // operator instantiation
op.connect(-1, my_stream_type);
op.connect(0, my_file_path);
op.connect(1, my_any_input_1);
op.connect(2, my_any_input_2);
std::string my_file_path = op.getOutput<std::string>(0);

result: wall shear stress

Description

Read Wall Shear Stress by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: wall_shear_stress
  • full name: result.wall_shear_stress
  • internal name: TAU
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.wall_shear_stress() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.wall_shear_stress() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("TAU"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: reaction force

Description

Read/compute nodal reaction forces by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • mapdl: rst,mode,rfrq,rdsp

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: reaction_force
  • full name: result.reaction_force
  • internal name: RF
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.reaction_force() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.reaction_force() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("RF"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: velocity

Description

Read/compute nodal velocities by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj
  • hdf5: h5dpf
  • lsdyna: moddynout,lsda,d3plot,d3psd,d3ssd
  • mapdl: mode,cms,rst,rfrq,rdsp,dsub

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: velocity
  • full name: result.velocity
  • internal name: V
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.velocity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.velocity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("V"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: reaction force X

Description

Read/compute nodal reaction forces X component of the vector (1st component) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: reaction_force_X
  • full name: result.reaction_force_X
  • internal name: RFX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.reaction_force_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.reaction_force_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("RFX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: velocity X

Description

Read/compute nodal velocities X component of the vector (1st component) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: velocity_X
  • full name: result.velocity_X
  • internal name: VX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.velocity_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.velocity_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("VX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

geo: cartesian to spherical coordinates (fields container)

Description

Converts 3D field from cartesian coordinates to spherical coordinates.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: geo
  • plugin: core
  • scripting name: cartesian_to_spherical_fc
  • full name: geo.cartesian_to_spherical_fc
  • internal name: cartesian_to_spherical_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.cartesian_to_spherical_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.cartesian_to_spherical_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("cartesian_to_spherical_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global external work (LSDyna)

Description

Read Global External Work (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_external_work
  • full name: result.global_external_work
  • internal name: GLOB_EW
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_external_work() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_external_work() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_EW"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: acceleration

Description

Read/compute nodal accelerations by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3ssd,moddynout,d3psd,d3plot,lsda
  • mapdl: cms,rst,mode,rdsp,rfrq,dsub

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: acceleration
  • full name: result.acceleration
  • internal name: A
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.acceleration() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.acceleration() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("A"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: element centroids

Description

Read/compute coordinate of the elemental centroids by calling the readers defined by the datasources.

Supported file types

  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: element_centroids
  • full name: result.element_centroids
  • internal name: centroids
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.element_centroids() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.element_centroids() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("centroids"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: acceleration Z

Description

Read/compute nodal accelerations Z component of the vector (3rd component) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: acceleration_Z
  • full name: result.acceleration_Z
  • internal name: AZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.acceleration_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.acceleration_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("AZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

scoping: rescope (fields container)

Description

Rescopes a field on the given scoping. If an ID does not exist in the original field, the default value (in 2) is used when defined.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
mesh_scopingname
(scoping | vector)expected type(s)
pin 2optional
default_valuename
(double | vector)expected type(s)

If pin 2 is used, the IDs not found in the field are added with this default value.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: rescope_fc
  • full name: scoping.rescope_fc
  • internal name: Rescope_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.rescope_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.default_value.Connect(my_default_value)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.rescope_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.default_value.connect(my_default_value)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("Rescope_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh_scoping);
op.connect(2, my_default_value);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: workflow to workflow_topology

Description

Creates a GenericDataContainer based on WorkflowTopology structure from a Workflow object, allowing to access its operators, operator connections, data connections, and exposed pins.

Inputs

pin 0requested
workflowname
(workflow)expected type(s)

Outputs

pin 0requested
workflow_topologyname
(generic_data_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: workflow_to_workflow_topology
  • full name: serialization.workflow_to_workflow_topology
  • internal name: workflow_to_workflow_topology
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.workflow_to_workflow_topology() # operator instantiation
op.inputs.workflow.Connect(my_workflow)
my_workflow_topology = op.outputs.workflow_topology.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.workflow_to_workflow_topology() # operator instantiation
op.inputs.workflow.connect(my_workflow)
my_workflow_topology = op.outputs.workflow_topology()
#include "dpf_api.h"

ansys::dpf::Operator op("workflow_to_workflow_topology"); // operator instantiation
op.connect(0, my_workflow);
ansys::dpf::GenericDataContainer my_workflow_topology = op.getOutput<ansys::dpf::GenericDataContainer>(0);

result: displacement

Description

Read/compute nodal displacements by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout,moddynout,d3psd,d3plot,d3ssd
  • mapdl: rfrq,rdsp,cms,rst,mode,dsub

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: displacement
  • full name: result.displacement
  • internal name: U
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.displacement() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.displacement() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("U"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: electric field Z

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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: electric_field_Z
  • full name: result.electric_field_Z
  • internal name: EFZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.electric_field_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.electric_field_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EFZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: displacement X

Description

Read/compute nodal displacements X component of the vector (1st component) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: displacement_X
  • full name: result.displacement_X
  • internal name: UX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.displacement_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.displacement_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("UX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

averaging: force_summation

Description

Computes the sum of elemental forces contribution on a set of nodes in Global Coordinate System. Equivalent to MAPDL FSUM & NFORCE commands. Supports Static, Transient, Modal & Harmonic analysis for thermal and structural degrees of freedom.

Inputs

pin 0optional
time_scopingname
(scoping | vector)expected type(s)

default = all time steps

pin 1optional
nodal_scopingname
(scoping)expected type(s)

Nodal Scoping. Set of nodes in which elemental contribution forces will be accumulated (default = all nodes)

pin 2optional
elemental_scopingname
(scoping)expected type(s)

Elemental Scoping. Set of elements contributing to the force calcuation. (default = all elements)

pin 3optional
streams_containername
(streams_container)expected type(s)

Streams container. Optional if using data sources.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Data sources. Optional if using a streams container.

pin 5optional
force_typename
(int32)expected type(s)

Type of force to be processed (0 - default: Total forces (static, damping, and inertia)., 1: Static forces, 2: Damping forces, 3: Inertia forces)

pin 6optional
spointname
(field)expected type(s)

Coordinate field of a point for moment summations. Defaults to (0,0,0).

Outputs

pin 0requested
force_accumulationname
(fields_container)expected type(s)
pin 1requested
moment_accumulationname
(fields_container)expected type(s)
pin 2requested
heat_accumulationname
(fields_container)expected type(s)
pin 10requested
forces_on_nodesname
(fields_container)expected type(s)
pin 11requested
moments_on_nodesname
(fields_container)expected type(s)
pin 12requested
heats_on_nodesname
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: force_summation
  • full name: averaging.force_summation
  • internal name: force_summation
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.force_summation() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.nodal_scoping.Connect(my_nodal_scoping)
op.inputs.elemental_scoping.Connect(my_elemental_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.force_type.Connect(my_force_type)
op.inputs.spoint.Connect(my_spoint)
my_force_accumulation = op.outputs.force_accumulation.GetData()
my_moment_accumulation = op.outputs.moment_accumulation.GetData()
my_heat_accumulation = op.outputs.heat_accumulation.GetData()
my_forces_on_nodes = op.outputs.forces_on_nodes.GetData()
my_moments_on_nodes = op.outputs.moments_on_nodes.GetData()
my_heats_on_nodes = op.outputs.heats_on_nodes.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.force_summation() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.nodal_scoping.connect(my_nodal_scoping)
op.inputs.elemental_scoping.connect(my_elemental_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.force_type.connect(my_force_type)
op.inputs.spoint.connect(my_spoint)
my_force_accumulation = op.outputs.force_accumulation()
my_moment_accumulation = op.outputs.moment_accumulation()
my_heat_accumulation = op.outputs.heat_accumulation()
my_forces_on_nodes = op.outputs.forces_on_nodes()
my_moments_on_nodes = op.outputs.moments_on_nodes()
my_heats_on_nodes = op.outputs.heats_on_nodes()
#include "dpf_api.h"

ansys::dpf::Operator op("force_summation"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_nodal_scoping);
op.connect(2, my_elemental_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_force_type);
op.connect(6, my_spoint);
ansys::dpf::FieldsContainer my_force_accumulation = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_moment_accumulation = op.getOutput<ansys::dpf::FieldsContainer>(1);
ansys::dpf::FieldsContainer my_heat_accumulation = op.getOutput<ansys::dpf::FieldsContainer>(2);
ansys::dpf::FieldsContainer my_forces_on_nodes = op.getOutput<ansys::dpf::FieldsContainer>(10);
ansys::dpf::FieldsContainer my_moments_on_nodes = op.getOutput<ansys::dpf::FieldsContainer>(11);
ansys::dpf::FieldsContainer my_heats_on_nodes = op.getOutput<ansys::dpf::FieldsContainer>(12);

result: displacement Y

Description

Read/compute nodal displacements Y component of the vector (2nd component) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: displacement_Y
  • full name: result.displacement_Y
  • internal name: UY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.displacement_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.displacement_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("UY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: electric field X

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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: electric_field_X
  • full name: result.electric_field_X
  • internal name: EFX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.electric_field_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.electric_field_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EFX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: displacement Z

Description

Read/compute nodal displacements Z component of the vector (3rd component) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: displacement_Z
  • full name: result.displacement_Z
  • internal name: UZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.displacement_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.displacement_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("UZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: heat flux X

Description

Read/compute heat flux 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: heat_flux_X
  • full name: result.heat_flux_X
  • internal name: TFX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.heat_flux_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.heat_flux_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("TFX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: heat flux Y

Description

Read/compute heat flux 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: heat_flux_Y
  • full name: result.heat_flux_Y
  • internal name: TFY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.heat_flux_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.heat_flux_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("TFY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: electric field

Description

Read/compute electric field by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: electric_field
  • full name: result.electric_field
  • internal name: EF
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.electric_field() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.electric_field() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EF"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: heat flux Z

Description

Read/compute heat flux 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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: heat_flux_Z
  • full name: result.heat_flux_Z
  • internal name: TFZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.heat_flux_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.heat_flux_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("TFZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: total contact moment

Description

Read/compute total contact moment by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: total_contact_moment
  • full name: result.total_contact_moment
  • internal name: CFTTOT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.total_contact_moment() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.total_contact_moment() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("CFTTOT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: element orientations

Description

Read/compute element euler angles by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rth,rst,mode,cms,rfrq,rdsp,dsub

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: element_orientations
  • full name: result.element_orientations
  • internal name: EUL
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.element_orientations() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.element_orientations() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EUL"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: serialize to hdf5

Description

This operator is deprecated: use 'hdf5::h5dpf::make_result_file' instead. Serialize the inputs in an hdf5 format.

Inputs

pin 0requested
file_pathname
(string)expected type(s)

output file path with .h5 extension

pin 1optional
export_floatsname
(bool)expected type(s)

converts double to float to reduce file size (default is true)

pin 2optional
export_flat_vectorsname
(bool)expected type(s)

if true, vectors and matrices data are exported flat (x1,y1,z1,x2,y2,z2..) (default is false)

pin 3, 4...requested, ellipsis
dataname

only the data set explicitly to export is exported

Outputs

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: serialize_to_hdf5
  • full name: serialization.serialize_to_hdf5
  • internal name: serialize_to_hdf5
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.serialize_to_hdf5() # operator instantiation
op.inputs.file_path.Connect(my_file_path)
op.inputs.export_floats.Connect(my_export_floats)
op.inputs.export_flat_vectors.Connect(my_export_flat_vectors)
op.inputs.data1.Connect(my_data_1)
op.inputs.data2.Connect(my_data_2)
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.serialize_to_hdf5() # operator instantiation
op.inputs.file_path.connect(my_file_path)
op.inputs.export_floats.connect(my_export_floats)
op.inputs.export_flat_vectors.connect(my_export_flat_vectors)
op.inputs.data1.connect(my_data_1)
op.inputs.data2.connect(my_data_2)
#include "dpf_api.h"

ansys::dpf::Operator op("serialize_to_hdf5"); // operator instantiation
op.connect(0, my_file_path);
op.connect(1, my_export_floats);
op.connect(2, my_export_flat_vectors);
op.connect(3, my_data_1);
op.connect(4, my_data_2);

result: element orientations Y

Description

Read/compute element euler angles 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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: element_orientations_Y
  • full name: result.element_orientations_Y
  • internal name: EULY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.element_orientations_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.element_orientations_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EULY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: magnetic field Z

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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: magnetic_field_Z
  • full name: result.magnetic_field_Z
  • internal name: MFZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.magnetic_field_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.magnetic_field_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MFZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

averaging: elemental mean (fields container)

Description

Computes the average of a multi-entity container of fields, (ElementalNodal -> Elemental), (NodalElemental -> Nodal). If the input fields are mixed shell/solid and collapseShellLayers is false, then the fields could be split by element shape and the output fields container would have an elshape label depending on the e_shell_layer and merge_solid_shell inputs (if e_shell_layer is not specified, the fields are split; if it is specified, the fields can be split based on merge_solid_shell).If collapseShellLayers is true, all available shell layers are collapsed and shells and solid fields are always merged.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
collapse_shell_layersname
(bool)expected type(s)

If true, the data across different shell layers is averaged as well (default is false).

pin 2optional
force_averagingname
(bool)expected type(s)

If true you average, if false you just sum.

pin 3optional
scopingname
(scoping | scopings_container)expected type(s)

Average only on these elements. If it is a scoping container, the label must correspond to the one of the fields container.

pin 4optional
abstract_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

The mesh region in this pin is used to perform the averaging. It is used if there is no fields support.

pin 26optional
merge_solid_shellname
(bool)expected type(s)

For shell/solid mixed fields, group in the same field all solids and shells (false by default). This pin only has an effect when collapse_shell_layers is false and a value for e_shell_layer is provided.

pin 27optional
e_shell_layername
(int32)expected type(s)

0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid. This pin only has an effect when collapse_shell_layers is false.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: elemental_mean_fc
  • full name: averaging.elemental_mean_fc
  • internal name: entity_average_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.elemental_mean_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.collapse_shell_layers.Connect(my_collapse_shell_layers)
op.inputs.force_averaging.Connect(my_force_averaging)
op.inputs.scoping.Connect(my_scoping)
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.merge_solid_shell.Connect(my_merge_solid_shell)
op.inputs.e_shell_layer.Connect(my_e_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.elemental_mean_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.collapse_shell_layers.connect(my_collapse_shell_layers)
op.inputs.force_averaging.connect(my_force_averaging)
op.inputs.scoping.connect(my_scoping)
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.merge_solid_shell.connect(my_merge_solid_shell)
op.inputs.e_shell_layer.connect(my_e_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("entity_average_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_collapse_shell_layers);
op.connect(2, my_force_averaging);
op.connect(3, my_scoping);
op.connect(4, my_abstract_meshed_region);
op.connect(26, my_merge_solid_shell);
op.connect(27, my_e_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: magnetic field Y

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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: magnetic_field_Y
  • full name: result.magnetic_field_Y
  • internal name: MFY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.magnetic_field_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.magnetic_field_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MFY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

mesh: split mesh wrt property

Description

Split the input mesh into several meshes based on a given property (material property be default)

Inputs

pin 1optional
mesh_scopingname
(scoping)expected type(s)

Scoping

pin 7requested
meshname
(abstract_meshed_region)expected type(s)
pin 13requested
propertyname
(string)expected type(s)

Outputs

pin 0requested
meshesname
(meshes_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: split_mesh
  • full name: mesh.split_mesh
  • internal name: split_mesh
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.split_mesh() # operator instantiation
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.mesh.Connect(my_mesh)
op.inputs.property.Connect(my_property)
my_meshes = op.outputs.meshes.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.split_mesh() # operator instantiation
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.mesh.connect(my_mesh)
op.inputs.property.connect(my_property)
my_meshes = op.outputs.meshes()
#include "dpf_api.h"

ansys::dpf::Operator op("split_mesh"); // operator instantiation
op.connect(1, my_mesh_scoping);
op.connect(7, my_mesh);
op.connect(13, my_property);
ansys::dpf::MeshesContainer my_meshes = op.getOutput<ansys::dpf::MeshesContainer>(0);

result: element orientations Z

Description

Read/compute element euler angles 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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: element_orientations_Z
  • full name: result.element_orientations_Z
  • internal name: EULZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.element_orientations_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.element_orientations_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EULZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: temperature gradient

Description

Read/compute Temperature Gradient by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: temperature_grad
  • full name: result.temperature_grad
  • internal name: TG
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.temperature_grad() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.temperature_grad() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("TG"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: cgns result provider

Description

Read/compute names result from result streams.

Inputs

pin 0optional
time_scopingname
(scoping | vector)expected type(s)

time/freq (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

pin 1optional
mesh_scopingname
(scoping | scopings_container)expected type(s)

nodes or elements scoping required in output. The scoping's location indicates whether nodes or elements are asked. Using scopings container enables to split the result fields container in domains

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 17optional
result_namename
(string)expected type(s)

name of the result to read. By default the name of the operator is taken.

pin 25optional
region_scopingname
(scoping | vector | int32)expected type(s)

Optional zone name/Id of the mesh.

Outputs

pin 0requested
fieldsname
(fields_container)expected type(s)

Results

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: cgns
  • scripting name: cgns_result_provider
  • full name: result.cgns_result_provider
  • internal name: cgns::cgns::result_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.cgns_result_provider() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.result_name.Connect(my_result_name)
op.inputs.region_scoping.Connect(my_region_scoping)
my_fields = op.outputs.fields.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.cgns_result_provider() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.result_name.connect(my_result_name)
op.inputs.region_scoping.connect(my_region_scoping)
my_fields = op.outputs.fields()
#include "dpf_api.h"

ansys::dpf::Operator op("cgns::cgns::result_provider"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(17, my_result_name);
op.connect(25, my_region_scoping);
ansys::dpf::FieldsContainer my_fields = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: temperature gradient X

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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: temperature_grad_X
  • full name: result.temperature_grad_X
  • internal name: TGX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.temperature_grad_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.temperature_grad_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("TGX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: entropy

Description

Read Entropy by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: entropy
  • full name: result.entropy
  • internal name: S_S
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.entropy() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.entropy() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("S_S"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: volume fraction

Description

Read Volume Fraction by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: volume_fraction
  • full name: result.volume_fraction
  • internal name: VOF
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.volume_fraction() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.volume_fraction() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("VOF"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: temperature gradient Y

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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: temperature_grad_Y
  • full name: result.temperature_grad_Y
  • internal name: TGY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.temperature_grad_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.temperature_grad_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("TGY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: temperature gradient Z

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.

Supported file types

  • hdf5: h5dpf

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: temperature_grad_Z
  • full name: result.temperature_grad_Z
  • internal name: TGZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.temperature_grad_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.temperature_grad_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("TGZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elemental summable miscellaneous data

Description

Read/compute elemental summable miscellaneous data by calling the readers defined by the datasources. Modal superposition (on demand expansion) and cyclic cxpansion procedures are supported, however, you should verify that the linear combination is applicable for the associated element according to the MAPDL documentation description of each item.

Supported file types

  • hdf5: h5dpf
  • mapdl: cms,rst,mode,rfrq,rdsp,rth,dsub

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 10optional
item_indexname
(int32)expected type(s)

Index of requested item.

pin 11optional
num_componentsname
(int32)expected type(s)

Number of components for the requested item.

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: smisc
  • full name: result.smisc
  • internal name: SMISC
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.smisc() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.item_index.Connect(my_item_index)
op.inputs.num_components.Connect(my_num_components)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.smisc() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.item_index.connect(my_item_index)
op.inputs.num_components.connect(my_num_components)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("SMISC"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(10, my_item_index);
op.connect(11, my_num_components);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: magnetic field

Description

Read/compute Magnetic Field by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: magnetic_field
  • full name: result.magnetic_field
  • internal name: MF
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.magnetic_field() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.magnetic_field() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MF"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute stress Z

Description

Computes the stress from an elastic strain field. compute_total_strain limitations are applicable for stress computation Get the ZZ normal component (22 component).

Inputs

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Needed to get mesh and material ids. Optional if a data_sources have been connected.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

Needed to get mesh and material ids. Optional if a streams_container have been connected.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10requested
strainname
(fields_container | field)expected type(s)

Field/or fields container containing only the elastic strain field (element nodal).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_stress_Z
  • full name: result.compute_stress_Z
  • internal name: compute_stress_Z
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_stress_Z() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.strain.Connect(my_strain)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_stress_Z() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.strain.connect(my_strain)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_stress_Z"); // operator instantiation
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(9, my_requested_location);
op.connect(10, my_strain);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: part eroded kinetic energy (LSDyna)

Description

Read Part Eroded Kinetic Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
entity_scopingname
(scoping)expected type(s)

entity (part for matsum, interface for rcforc) where the result will be scoped

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: part_eroded_kinetic_energy
  • full name: result.part_eroded_kinetic_energy
  • internal name: M_ERKE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.part_eroded_kinetic_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.entity_scoping.Connect(my_entity_scoping)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.part_eroded_kinetic_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.entity_scoping.connect(my_entity_scoping)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("M_ERKE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_entity_scoping);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: string deserializer

Description

Takes a string generated by the serializer and deserializes it into DPF's entities.

Inputs

pin -1requested
stream_typename
(int32)expected type(s)

0 for string (default), and 1 for binary

pin 0, 1...requested, ellipsis
serialized_stringname
(string)expected type(s)

Outputs

pin 1, 2...requested, ellipsis
any_outputname
(any)expected type(s)

number and types of outputs corresponding of the inputs used in the serialization

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: string_deserializer
  • full name: serialization.string_deserializer
  • internal name: string_deserializer
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.string_deserializer() # operator instantiation
op.inputs.stream_type.Connect(my_stream_type)
op.inputs.serialized_string1.Connect(my_serialized_string_1)
op.inputs.serialized_string2.Connect(my_serialized_string_2)
my_any_output = op.outputs.any_output.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.string_deserializer() # operator instantiation
op.inputs.stream_type.connect(my_stream_type)
op.inputs.serialized_string1.connect(my_serialized_string_1)
op.inputs.serialized_string2.connect(my_serialized_string_2)
my_any_output = op.outputs.any_output()
#include "dpf_api.h"

ansys::dpf::Operator op("string_deserializer"); // operator instantiation
op.connect(-1, my_stream_type);
op.connect(0, my_serialized_string_1);
op.connect(1, my_serialized_string_2);
ansys::dpf::Any my_any_output = op.getOutput<ansys::dpf::Any>(1);

result: magnetic field X

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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: magnetic_field_X
  • full name: result.magnetic_field_X
  • internal name: MFX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.magnetic_field_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.magnetic_field_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MFX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: magnetic flux density

Description

Read/compute Magnetic Flux Density by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: magnetic_flux_density
  • full name: result.magnetic_flux_density
  • internal name: MFD
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.magnetic_flux_density() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.magnetic_flux_density() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MFD"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: magnetic flux density X

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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: magnetic_flux_density_X
  • full name: result.magnetic_flux_density_X
  • internal name: MFDX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.magnetic_flux_density_X() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.magnetic_flux_density_X() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MFDX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: magnetic flux density Y

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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: magnetic_flux_density_Y
  • full name: result.magnetic_flux_density_Y
  • internal name: MFDY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.magnetic_flux_density_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.magnetic_flux_density_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MFDY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: nodal force

Description

Read/compute nodal forces by calling the readers defined by the datasources.

Supported file types

  • lsdyna: moddynout
  • mapdl: rfrq,rdsp

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: nodal_force
  • full name: result.nodal_force
  • internal name: F
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.nodal_force() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.nodal_force() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("F"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: magnetic flux density Z

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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: magnetic_flux_density_Z
  • full name: result.magnetic_flux_density_Z
  • internal name: MFDZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.magnetic_flux_density_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.magnetic_flux_density_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MFDZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: electric field Y

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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: electric_field_Y
  • full name: result.electric_field_Y
  • internal name: EFY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.electric_field_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.electric_field_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EFY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: electric flux density Z

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.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

FieldsContainer already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true)

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location, default is Nodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: electric_flux_density_Z
  • full name: result.electric_flux_density_Z
  • internal name: EFDZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.electric_flux_density_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.read_beams.Connect(my_read_beams)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.electric_flux_density_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.read_beams.connect(my_read_beams)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EFDZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(22, my_read_beams);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: element nodal forces

Description

Read/compute element nodal forces by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst,mode,cms,rth,rfrq,dsub

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

pin 200optional
split_force_componentsname
(bool)expected type(s)

If this pin is set to true, the output fields container splits the ENF by degree of freedom ("dof" label, 0 for translation, 1 for rotation, 2 for temperature) and derivative order ("derivative_order" label, 0 for stiffness terms, 1 for damping terms and 2 for inertial terms). Default is false.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: element_nodal_forces
  • full name: result.element_nodal_forces
  • internal name: ENF
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.element_nodal_forces() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
op.inputs.split_force_components.Connect(my_split_force_components)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.element_nodal_forces() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
op.inputs.split_force_components.connect(my_split_force_components)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENF"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
op.connect(200, my_split_force_components);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute total strain Z

Description

Computes the strain from a displacement field. Only SOLID185 (B-Bar, Simplified Enhanced Strain, Enhanced Strain formulations), SOLID186 (Full Integration) & SOLID187 elements are supported. Layered elements are not supported. Thermal strains are not supported. Only one value of material properties are allowed per element for isotropic and orthotropic elasticity. Material nonlinearity is not supported 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

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.. Will only be used if no displacement input is given (will be applied on displacement operator).

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Optional if a mesh or a data_sources have been connected. Required if no displacement input have been connected.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Optional if a mesh or a streams_container have been connected, or if the displacement's field has a mesh support. Required if no displacement input have been connected.

pin 5optional
extrapolatename
(int32)expected type(s)

Whether to extrapolate the data from the integration points to the nodes.

pin 6optional
nonlinearname
(int32)expected type(s)

Whether to use nonlinear geometry or nonlinear material (1 = large strain, 2 = hyperelasticity).

pin 7optional
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

The underlying mesh. Optional if a data_sources or a streams_container have been connected, or if the displacement's field has a mesh support.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10optional
displacementname
(fields_container | field)expected type(s)

Field/or fields container containing only the displacement field (nodal). If none specified, read displacements from result file using the data_sources.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_total_strain_Z
  • full name: result.compute_total_strain_Z
  • internal name: compute_total_strain_Z
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_total_strain_Z() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.extrapolate.Connect(my_extrapolate)
op.inputs.nonlinear.Connect(my_nonlinear)
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.displacement.Connect(my_displacement)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_total_strain_Z() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.extrapolate.connect(my_extrapolate)
op.inputs.nonlinear.connect(my_nonlinear)
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.displacement.connect(my_displacement)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_total_strain_Z"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_extrapolate);
op.connect(6, my_nonlinear);
op.connect(7, my_abstract_meshed_region);
op.connect(9, my_requested_location);
op.connect(10, my_displacement);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: structural temperature

Description

Read/compute element structural nodal temperatures by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rth,rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: structural_temperature
  • full name: result.structural_temperature
  • internal name: BFE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.structural_temperature() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.structural_temperature() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("BFE"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

metadata: result info provider

Description

Reads the result information, such as available results or unit systems from the results files contained in the streams or data sources.

Supported file types

  • cff: cas,flprj
  • cgns: cgns
  • hdf5: h5dpf
  • lsdyna: d3ssd,d3acs,d3atv,moddynout,lsda,d3plot,d3psd,d3acp,binout
  • mapdl: cms,mode,rst,rfrq,rdsp,rth,dsub
  • vtk: vtk

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

streams (result file container) (optional)

pin 4requested
data_sourcesname
(data_sources)expected type(s)

If the stream is null, retrieves the file path from the data sources.

Outputs

pin 0requested
result_infoname
(result_info)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: result_info_provider
  • full name: metadata.result_info_provider
  • internal name: result_info_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.result_info_provider() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_result_info = op.outputs.result_info.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.result_info_provider() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_result_info = op.outputs.result_info()
#include "dpf_api.h"

ansys::dpf::Operator op("result_info_provider"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::ResultInfo my_result_info = op.getOutput<ansys::dpf::ResultInfo>(0);

filter: band pass (timescoping)

Description

The band pass filter returns all the values above (but not equal to) the minimum threshold value and below (but not equal to) the maximum threshold value in input.

Inputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1requested
min_thresholdname
(double | field)expected type(s)

A minimum threshold scalar or a field containing one value is expected.

pin 2optional
max_thresholdname
(double | field)expected type(s)

A maximum threshold scalar or a field containing one value is expected.

Outputs

pin 0requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: timescoping_band_pass
  • full name: filter.timescoping_band_pass
  • internal name: core::timescoping::band_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.timescoping_band_pass() # operator instantiation
op.inputs.time_freq_support.Connect(my_time_freq_support)
op.inputs.min_threshold.Connect(my_min_threshold)
op.inputs.max_threshold.Connect(my_max_threshold)
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.timescoping_band_pass() # operator instantiation
op.inputs.time_freq_support.connect(my_time_freq_support)
op.inputs.min_threshold.connect(my_min_threshold)
op.inputs.max_threshold.connect(my_max_threshold)
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("core::timescoping::band_pass"); // operator instantiation
op.connect(0, my_time_freq_support);
op.connect(1, my_min_threshold);
op.connect(2, my_max_threshold);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(0);

result: stress ratio

Description

Read/compute element nodal stress ratio by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: stress_ratio
  • full name: result.stress_ratio
  • internal name: ENL_SRAT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_ratio() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_ratio() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENL_SRAT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

mesh: skin (tri mesh)

Description

Extracts a skin of the mesh in triangles in a new meshed region.

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)
pin 1optional
include_surfacesname
(bool)expected type(s)

True: meshing will also take into account shell and skin elements. False: meshing will ignore shell and skin elements. The default is false.

pin 2optional
mesh_scopingname
(scoping)expected type(s)

Nodal scoping to restrict the skin extraction to a set of nodes. If provided, a skin element is added to the skin mesh if all its nodes are in the scoping.

Outputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)
pin 1requested
nodes_mesh_scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: tri_mesh_skin
  • full name: mesh.tri_mesh_skin
  • internal name: meshed_skin_sector_triangle
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.tri_mesh_skin() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
op.inputs.include_surfaces.Connect(my_include_surfaces)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
my_mesh = op.outputs.mesh.GetData()
my_nodes_mesh_scoping = op.outputs.nodes_mesh_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.tri_mesh_skin() # operator instantiation
op.inputs.mesh.connect(my_mesh)
op.inputs.include_surfaces.connect(my_include_surfaces)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
my_mesh = op.outputs.mesh()
my_nodes_mesh_scoping = op.outputs.nodes_mesh_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("meshed_skin_sector_triangle"); // operator instantiation
op.connect(0, my_mesh);
op.connect(1, my_include_surfaces);
op.connect(2, my_mesh_scoping);
ansys::dpf::MeshedRegion my_mesh = op.getOutput<ansys::dpf::MeshedRegion>(0);
ansys::dpf::Scoping my_nodes_mesh_scoping = op.getOutput<ansys::dpf::Scoping>(1);

result: accu eqv plastic strain

Description

Read/compute element nodal accumulated equivalent plastic strain by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: accu_eqv_plastic_strain
  • full name: result.accu_eqv_plastic_strain
  • internal name: ENL_EPEQ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.accu_eqv_plastic_strain() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.accu_eqv_plastic_strain() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENL_EPEQ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: plastic state variable

Description

Read/compute element nodal plastic state variable by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_state_variable
  • full name: result.plastic_state_variable
  • internal name: ENL_PSV
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_state_variable() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_state_variable() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENL_PSV"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: accu eqv creep strain

Description

Read/compute element nodal accumulated equivalent creep strain by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: accu_eqv_creep_strain
  • full name: result.accu_eqv_creep_strain
  • internal name: ENL_CREQ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.accu_eqv_creep_strain() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.accu_eqv_creep_strain() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENL_CREQ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: plastic strain energy density

Description

Read/compute element nodal plastic strain energy density by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: plastic_strain_energy_density
  • full name: result.plastic_strain_energy_density
  • internal name: ENL_PLWK
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_energy_density() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_energy_density() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENL_PLWK"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: material property of element

Description

Loads the appropriate operator based on the data sources and retrieves material properties.

Supported file types

  • mapdl: rth,rst

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
material_propertiesname
(field)expected type(s)

material properties

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: material_property_of_element
  • full name: result.material_property_of_element
  • internal name: MaterialPropertyOfElement
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.material_property_of_element() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_material_properties = op.outputs.material_properties.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.material_property_of_element() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_material_properties = op.outputs.material_properties()
#include "dpf_api.h"

ansys::dpf::Operator op("MaterialPropertyOfElement"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::Field my_material_properties = op.getOutput<ansys::dpf::Field>(0);

result: creep strain energy density

Description

Read/compute element nodal creep strain energy density by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: creep_strain_energy_density
  • full name: result.creep_strain_energy_density
  • internal name: ENL_CRWK
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.creep_strain_energy_density() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.creep_strain_energy_density() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENL_CRWK"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: erp radiation efficiency

Description

Compute the radiation efficiency (enhanced erp divided by classical erp)

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

the input field container expects displacements fields

pin 1requested
meshname
(abstract_meshed_region | meshes_container)expected type(s)

the meshes region in this pin has to be boundary or skin mesh

pin 2requested
time_scopingname
(int32 | vector | scoping)expected type(s)

load step number (if it's specified, the ERP is computed only on the substeps of this step) or time scoping

pin 3requested
mass_densityname
(double)expected type(s)

mass density (if it's not specified, default value of the air is applied).

pin 4requested
speed_of_soundname
(double)expected type(s)

speed of sound (if it's not specified, default value of the speed of sound in the air is applied).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: erp_radiation_efficiency
  • full name: result.erp_radiation_efficiency
  • internal name: erp_radiation_efficiency
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.erp_radiation_efficiency() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mass_density.Connect(my_mass_density)
op.inputs.speed_of_sound.Connect(my_speed_of_sound)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.erp_radiation_efficiency() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mass_density.connect(my_mass_density)
op.inputs.speed_of_sound.connect(my_speed_of_sound)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("erp_radiation_efficiency"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(2, my_time_scoping);
op.connect(3, my_mass_density);
op.connect(4, my_speed_of_sound);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain energy density

Description

Read/compute element nodal elastic strain energy density by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elastic_strain_energy_density
  • full name: result.elastic_strain_energy_density
  • internal name: ENL_ELENG
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_energy_density() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_energy_density() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENL_ELENG"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: field to csv

Description

Exports a field or a fields container into a csv file

Inputs

pin 0requested
field_or_fields_containername
(fields_container | field)expected type(s)

field_or_fields_container

pin 1requested
file_pathname
(string)expected type(s)
pin 2optional
storage_typename
(int32)expected type(s)

storage type : if matrices (without any particularity) are included in the fields container, the storage format can be chosen. 0 : flat/line format, 1 : ranked format. If 1 is chosen, the csv can not be read by "csv to field" operator anymore. Default : 0.

Outputs

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: csv
  • scripting name: field_to_csv
  • full name: serialization.field_to_csv
  • internal name: field_to_csv
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.field_to_csv() # operator instantiation
op.inputs.field_or_fields_container.Connect(my_field_or_fields_container)
op.inputs.file_path.Connect(my_file_path)
op.inputs.storage_type.Connect(my_storage_type)
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.field_to_csv() # operator instantiation
op.inputs.field_or_fields_container.connect(my_field_or_fields_container)
op.inputs.file_path.connect(my_file_path)
op.inputs.storage_type.connect(my_storage_type)
#include "dpf_api.h"

ansys::dpf::Operator op("field_to_csv"); // operator instantiation
op.connect(0, my_field_or_fields_container);
op.connect(1, my_file_path);
op.connect(2, my_storage_type);

result: contact status

Description

Read/compute element contact status by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rth,rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: contact_status
  • full name: result.contact_status
  • internal name: ECT_STAT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.contact_status() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.contact_status() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ECT_STAT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: contact penetration

Description

Read/compute element contact penetration by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot
  • mapdl: rth,rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: contact_penetration
  • full name: result.contact_penetration
  • internal name: ECT_PENE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.contact_penetration() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.contact_penetration() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ECT_PENE"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: contact friction stress

Description

Read/compute element contact friction stress by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: contact_friction_stress
  • full name: result.contact_friction_stress
  • internal name: ECT_SFRIC
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.contact_friction_stress() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.contact_friction_stress() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ECT_SFRIC"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: contact total stress

Description

Read/compute element contact total stress (pressure plus friction) by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rth,rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: contact_total_stress
  • full name: result.contact_total_stress
  • internal name: ECT_STOT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.contact_total_stress() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.contact_total_stress() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ECT_STOT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global joint internal energy (LSDyna)

Description

Read Global Joint Internal Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_joint_internal_energy
  • full name: result.global_joint_internal_energy
  • internal name: GLOB_JE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_joint_internal_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_joint_internal_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_JE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: merge generic data container

Description

Merges a list of generic data container. For each data entry, the merge operation is forwarded to the correct merge Operator. Primitive types cannot be merged, first instance found will be maintained in the result.

Inputs

pin 0, 1...requested, ellipsis
generic_data_containername
(generic_data_container | vector>)expected type(s)

Either a vector of generic data containers (sharing the same data types) or generic data containers from pin 0 to ... to merge. Supported types rely on existing type specific merge operators.

Outputs

pin 0requested
generic_data_containername
(generic_data_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_generic_data_container
  • full name: utility.merge_generic_data_container
  • internal name: merge::generic_data_container
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_generic_data_container() # operator instantiation
op.inputs.generic_data_container1.Connect(my_generic_data_container_1)
op.inputs.generic_data_container2.Connect(my_generic_data_container_2)
my_generic_data_container = op.outputs.generic_data_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_generic_data_container() # operator instantiation
op.inputs.generic_data_container1.connect(my_generic_data_container_1)
op.inputs.generic_data_container2.connect(my_generic_data_container_2)
my_generic_data_container = op.outputs.generic_data_container()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::generic_data_container"); // operator instantiation
op.connect(0, my_generic_data_container_1);
op.connect(1, my_generic_data_container_2);
ansys::dpf::GenericDataContainer my_generic_data_container = op.getOutput<ansys::dpf::GenericDataContainer>(0);

result: contact sliding distance

Description

Read/compute element contact sliding distance by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rth,rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: contact_sliding_distance
  • full name: result.contact_sliding_distance
  • internal name: ECT_SLIDE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.contact_sliding_distance() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.contact_sliding_distance() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ECT_SLIDE"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: vtk to fields

Description

Write a field based on a vtk file.

Inputs

pin 0optional
field_namename
(string)expected type(s)

name of the field in the vtk file

pin 3optional
streamsname
(streams_container)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

fields_container

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: vtk
  • scripting name: vtk_to_fields
  • full name: serialization.vtk_to_fields
  • internal name: vtk::vtk::FieldProvider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.vtk_to_fields() # operator instantiation
op.inputs.field_name.Connect(my_field_name)
op.inputs.streams.Connect(my_streams)
op.inputs.data_sources.Connect(my_data_sources)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.vtk_to_fields() # operator instantiation
op.inputs.field_name.connect(my_field_name)
op.inputs.streams.connect(my_streams)
op.inputs.data_sources.connect(my_data_sources)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("vtk::vtk::FieldProvider"); // operator instantiation
op.connect(0, my_field_name);
op.connect(3, my_streams);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: contact gap distance

Description

Read/compute element contact gap distance by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: contact_gap_distance
  • full name: result.contact_gap_distance
  • internal name: ECT_GAP
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.contact_gap_distance() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.contact_gap_distance() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ECT_GAP"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: contact surface heat flux

Description

Read/compute element total heat flux at contact surface by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: contact_surface_heat_flux
  • full name: result.contact_surface_heat_flux
  • internal name: ECT_FLUX
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.contact_surface_heat_flux() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.contact_surface_heat_flux() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ECT_FLUX"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: artificial hourglass energy

Description

Read/compute artificial hourglass energy by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: artificial_hourglass_energy
  • full name: result.artificial_hourglass_energy
  • internal name: ENG_AHO
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.artificial_hourglass_energy() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.artificial_hourglass_energy() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENG_AHO"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: kinetic energy

Description

Read/compute kinetic energy by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • mapdl: mode,rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: kinetic_energy
  • full name: result.kinetic_energy
  • internal name: ENG_KE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.kinetic_energy() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.kinetic_energy() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENG_KE"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: thermal dissipation energy

Description

Read/compute thermal dissipation energy by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: thermal_dissipation_energy
  • full name: result.thermal_dissipation_energy
  • internal name: ENG_TH
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thermal_dissipation_energy() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thermal_dissipation_energy() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ENG_TH"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: rms static pressure

Description

Read RMS Static Pressure by calling the readers defined by the datasources.

Supported file types

  • cff: flprj,cas

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: rms_static_pressure
  • full name: result.rms_static_pressure
  • internal name: P_SRMS
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.rms_static_pressure() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.rms_static_pressure() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("P_SRMS"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: swelling strains

Description

Read/compute element nodal swelling strains by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: swelling_strains
  • full name: result.swelling_strains
  • internal name: ETH_SWL
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.swelling_strains() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.swelling_strains() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ETH_SWL"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: total contact force

Description

Read/compute total contact force by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: total_contact_force
  • full name: result.total_contact_force
  • internal name: CFFTOT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.total_contact_force() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.total_contact_force() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("CFFTOT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: temperature

Description

Read/compute temperature field by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj
  • hdf5: h5dpf
  • lsdyna: d3plot
  • mapdl: rth,rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: temperature
  • full name: result.temperature
  • internal name: TEMP
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.temperature() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.temperature() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("TEMP"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute stress

Description

Computes the stress from an elastic strain field. compute_total_strain limitations are applicable for stress computation

Inputs

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Needed to get mesh and material ids. Optional if a data_sources have been connected.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

Needed to get mesh and material ids. Optional if a streams_container have been connected.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10requested
strainname
(fields_container | field)expected type(s)

Field/or fields container containing only the elastic strain field (element nodal).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_stress
  • full name: result.compute_stress
  • internal name: compute_stress
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_stress() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.strain.Connect(my_strain)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_stress() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.strain.connect(my_strain)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_stress"); // operator instantiation
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(9, my_requested_location);
op.connect(10, my_strain);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: raw displacement

Description

Read/compute U vector from the finite element problem KU=F by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • mapdl: dsub,rfrq,rdsp,rth,rst,mode,cms

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: raw_displacement
  • full name: result.raw_displacement
  • internal name: UTOT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.raw_displacement() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.raw_displacement() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("UTOT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: raw reaction force

Description

Read/compute F vector from the finite element problem KU=F by calling the readers defined by the datasources.

Supported file types

  • mapdl: rth,rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: raw_reaction_force
  • full name: result.raw_reaction_force
  • internal name: RFTOT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.raw_reaction_force() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.raw_reaction_force() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("RFTOT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: turbulent kinetic energy (k)

Description

Read Turbulent Kinetic Energy (k) by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: turbulent_kinetic_energy
  • full name: result.turbulent_kinetic_energy
  • internal name: K
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.turbulent_kinetic_energy() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.turbulent_kinetic_energy() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("K"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: electric potential

Description

Read/compute electric Potential by calling the readers defined by the datasources.

Supported file types

  • mapdl: rth,rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: electric_potential
  • full name: result.electric_potential
  • internal name: VOLT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.electric_potential() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.electric_potential() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("VOLT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: thickness

Description

Read/compute thickness by calling the readers defined by the datasources.

Supported file types

  • lsdyna: d3plot
  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: thickness
  • full name: result.thickness
  • internal name: thickness
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thickness() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thickness() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("thickness"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: mapdl run

Description

Solve in mapdl a dat/inp file and returns a datasources with the rst file.

Inputs

pin 0optional
mapdl_exe_pathname
(string)expected type(s)
pin 1optional
working_dirname
(string)expected type(s)
pin 2optional
number_of_processesname
(int32)expected type(s)

Set the number of MPI processes used for resolution (default is 2)

pin 3optional
number_of_threadsname
(int32)expected type(s)

Set the number of threads used for resolution (default is 1)

pin 4requested
data_sourcesname
(data_sources)expected type(s)

data sources containing the input file.

pin 5optional
server_modename
(bool)expected type(s)

used when a user includes commands in the input file allowing to launch DPF server inside MAPDL to interact with MAPDL using DPF client API

Outputs

pin 0requested
data_sourcesname
(data_sources)expected type(s)

returns the data source if the server_mode pin is not set to yes

pin 1requested
ipname
(string)expected type(s)

returns the Ip if the server_mode pin is set to yes

pin 2requested
portname
(string)expected type(s)

returns a port when the server mode pin is set to yes

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: mapdl.run
  • full name: result.mapdl.run
  • internal name: mapdl::run
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mapdl.run() # operator instantiation
op.inputs.mapdl_exe_path.Connect(my_mapdl_exe_path)
op.inputs.working_dir.Connect(my_working_dir)
op.inputs.number_of_processes.Connect(my_number_of_processes)
op.inputs.number_of_threads.Connect(my_number_of_threads)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.server_mode.Connect(my_server_mode)
my_data_sources = op.outputs.data_sources.GetData()
my_ip = op.outputs.ip.GetData()
my_port = op.outputs.port.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mapdl.run() # operator instantiation
op.inputs.mapdl_exe_path.connect(my_mapdl_exe_path)
op.inputs.working_dir.connect(my_working_dir)
op.inputs.number_of_processes.connect(my_number_of_processes)
op.inputs.number_of_threads.connect(my_number_of_threads)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.server_mode.connect(my_server_mode)
my_data_sources = op.outputs.data_sources()
my_ip = op.outputs.ip()
my_port = op.outputs.port()
#include "dpf_api.h"

ansys::dpf::Operator op("mapdl::run"); // operator instantiation
op.connect(0, my_mapdl_exe_path);
op.connect(1, my_working_dir);
op.connect(2, my_number_of_processes);
op.connect(3, my_number_of_threads);
op.connect(4, my_data_sources);
op.connect(5, my_server_mode);
ansys::dpf::DataSources my_data_sources = op.getOutput<ansys::dpf::DataSources>(0);
std::string my_ip = op.getOutput<std::string>(1);
std::string my_port = op.getOutput<std::string>(2);

result: equivalent mass

Description

Read/compute equivalent dof mass by calling the readers defined by the datasources.

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
all_dofsname
(bool)expected type(s)

default is false.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: equivalent_mass
  • full name: result.equivalent_mass
  • internal name: equivalent_mass
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.equivalent_mass() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.all_dofs.Connect(my_all_dofs)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.equivalent_mass() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.all_dofs.connect(my_all_dofs)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("equivalent_mass"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_all_dofs);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: result provider

Description

Read/compute user defined result by calling the readers defined by the datasources.

Supported file types

  • cgns: cgns

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 60requested
result_namename

Specifies the scripting name of the raw/internal Name of the result to extract from the file

pin 64optional
result_scripting_namename

Specifies the scripting name of the result to extract;see ResultInfo for details. Use either "result name" or "result scripting name" with their appropriate pin, but not both.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: result_provider
  • full name: result.result_provider
  • internal name: result_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.result_provider() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.result_name.Connect(my_result_name)
op.inputs.result_scripting_name.Connect(my_result_scripting_name)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.result_provider() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.result_name.connect(my_result_name)
op.inputs.result_scripting_name.connect(my_result_scripting_name)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("result_provider"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(60, my_result_name);
op.connect(64, my_result_scripting_name);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elemental heat generation

Description

Read/compute Elemental Heat Generation by calling the readers defined by the datasources.

Supported file types

  • mapdl: rth,rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: elemental_heat_generation
  • full name: result.elemental_heat_generation
  • internal name: EHC
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elemental_heat_generation() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elemental_heat_generation() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EHC"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: magnetic vector potential

Description

Read/compute Magnetic Vector Potential by calling the readers defined by the datasources.

Supported file types

  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: magnetic_vector_potential
  • full name: result.magnetic_vector_potential
  • internal name: MVP
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.magnetic_vector_potential() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.magnetic_vector_potential() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MVP"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

invariant: von mises eqv (field)

Description

Computes the element-wise Von-Mises criteria on a tensor field.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 13requested
poisson_rationame
(double | int32)expected type(s)

Poisson ratio to be used in equivalent strain calculation.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: invariant
  • plugin: core
  • scripting name: von_mises_eqv
  • full name: invariant.von_mises_eqv
  • internal name: eqv
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.von_mises_eqv() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.poisson_ratio.Connect(my_poisson_ratio)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.von_mises_eqv() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.poisson_ratio.connect(my_poisson_ratio)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("eqv"); // operator instantiation
op.connect(0, my_field);
op.connect(13, my_poisson_ratio);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: merge fields into field matrix

Description

Assembles a set of fields into a field matrix.

Inputs

pin 0, 1...requested, ellipsis
fieldsname
(vector> | field | fields_container)expected type(s)

Either a fields container, a vector of fields to merge, or fields from pin 0 to ...

Outputs

pin 0requested
merged_field_matrixname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_to_field_matrix
  • full name: utility.merge_to_field_matrix
  • internal name: merge::to_field_matrix
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_to_field_matrix() # operator instantiation
op.inputs.fields1.Connect(my_fields_1)
op.inputs.fields2.Connect(my_fields_2)
my_merged_field_matrix = op.outputs.merged_field_matrix.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_to_field_matrix() # operator instantiation
op.inputs.fields1.connect(my_fields_1)
op.inputs.fields2.connect(my_fields_2)
my_merged_field_matrix = op.outputs.merged_field_matrix()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::to_field_matrix"); // operator instantiation
op.connect(0, my_fields_1);
op.connect(1, my_fields_2);
ansys::dpf::Field my_merged_field_matrix = op.getOutput<ansys::dpf::Field>(0);

result: beam axial plastic strain (LSDyna)

Description

Read Beam Axial Plastic strain (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
integration_pointname
(int32)expected type(s)

integration point where the result will be read from. Default value: 0 (first integration point).

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: beam_axial_plastic_strain
  • full name: result.beam_axial_plastic_strain
  • internal name: B_EPPL
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.beam_axial_plastic_strain() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.integration_point.Connect(my_integration_point)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.beam_axial_plastic_strain() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.integration_point.connect(my_integration_point)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("B_EPPL"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_integration_point);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

invariant: segalman von mises eqv (field)

Description

Computes the element-wise Segalman Von-Mises criteria on a tensor field.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: invariant
  • plugin: core
  • scripting name: segalman_von_mises_eqv
  • full name: invariant.segalman_von_mises_eqv
  • internal name: segalmaneqv
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.segalman_von_mises_eqv() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.segalman_von_mises_eqv() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("segalmaneqv"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: joint force reaction

Description

Read/compute joint force reaction by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: joint_force_reaction
  • full name: result.joint_force_reaction
  • internal name: JFL
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.joint_force_reaction() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.joint_force_reaction() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("JFL"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: joint moment reaction

Description

Read/compute joint moment reaction by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: joint_moment_reaction
  • full name: result.joint_moment_reaction
  • internal name: JML
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.joint_moment_reaction() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.joint_moment_reaction() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("JML"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: beam T shear force (LSDyna)

Description

Read Beam T Shear Force (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: beam_t_shear_force
  • full name: result.beam_t_shear_force
  • internal name: B_T2
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.beam_t_shear_force() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.beam_t_shear_force() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("B_T2"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: joint relative displacement

Description

Read/compute joint relative displacement by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: joint_relative_displacement
  • full name: result.joint_relative_displacement
  • internal name: JU
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.joint_relative_displacement() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.joint_relative_displacement() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("JU"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: joint relative rotation

Description

Read/compute joint relative rotation by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: joint_relative_rotation
  • full name: result.joint_relative_rotation
  • internal name: JR
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.joint_relative_rotation() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.joint_relative_rotation() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("JR"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: joint relative velocity

Description

Read/compute joint relative velocity by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: joint_relative_velocity
  • full name: result.joint_relative_velocity
  • internal name: JV
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.joint_relative_velocity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.joint_relative_velocity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("JV"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: joint relative acceleration

Description

Read/compute joint relative acceleration by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: joint_relative_acceleration
  • full name: result.joint_relative_acceleration
  • internal name: JA
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.joint_relative_acceleration() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.joint_relative_acceleration() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("JA"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: joint relative angular acceleration

Description

Read/compute joint relative angular acceleration by calling the readers defined by the datasources.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: joint_relative_angular_acceleration
  • full name: result.joint_relative_angular_acceleration
  • internal name: JDOMG
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.joint_relative_angular_acceleration() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.joint_relative_angular_acceleration() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("JDOMG"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global internal energy (LSDyna)

Description

Read Global Internal Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot,binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_internal_energy
  • full name: result.global_internal_energy
  • internal name: GLOB_ENG_IE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_internal_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_internal_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_ENG_IE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: txt to data tree

Description

Reads a txt file or string to a DataTree

Inputs

pin 0requested
string_or_pathname
(string | data_sources)expected type(s)

Outputs

pin 0requested
data_treename
(abstract_data_tree)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: txt_to_data_tree
  • full name: serialization.txt_to_data_tree
  • internal name: txt_to_data_tree
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.txt_to_data_tree() # operator instantiation
op.inputs.string_or_path.Connect(my_string_or_path)
my_data_tree = op.outputs.data_tree.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.txt_to_data_tree() # operator instantiation
op.inputs.string_or_path.connect(my_string_or_path)
my_data_tree = op.outputs.data_tree()
#include "dpf_api.h"

ansys::dpf::Operator op("txt_to_data_tree"); // operator instantiation
op.connect(0, my_string_or_path);
ansys::dpf::AbstractDataTree my_data_tree = op.getOutput<ansys::dpf::AbstractDataTree>(0);

result: thermal strains eqv

Description

Read/compute element nodal equivalent component thermal strains by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: thermal_strains_eqv
  • full name: result.thermal_strains_eqv
  • internal name: ETH_EQV
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thermal_strains_eqv() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thermal_strains_eqv() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ETH_EQV"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elemental non summable miscellaneous data

Description

Read/compute elemental non summable miscellaneous data by calling the readers defined by the datasources. Modal superposition (on demand expansion) and cyclic cxpansion procedures are not supported since results cannot be summed.

Supported file types

  • hdf5: h5dpf
  • mapdl: mode,rst,cms,rth,rfrq,rdsp,dsub

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 10optional
item_indexname
(int32)expected type(s)

Index of requested item.

pin 11optional
num_componentsname
(int32)expected type(s)

Number of components for the requested item.

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: nmisc
  • full name: result.nmisc
  • internal name: NMISC
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.nmisc() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.item_index.Connect(my_item_index)
op.inputs.num_components.Connect(my_num_components)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.nmisc() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.item_index.connect(my_item_index)
op.inputs.num_components.connect(my_num_components)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("NMISC"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(10, my_item_index);
op.connect(11, my_num_components);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: state variable

Description

Read/compute elemental state variable by calling the readers defined by the datasources.

  • The 'requested_location' and 'mesh_scoping' inputs are processed to see if they need scoping transposition or result averaging. The resulting output fields have a 'Nodal', 'ElementalNodal' or 'Elemental' location.
  • Once the need for averaging has been detected, the behavior of the combined connection of the 'split_shells' and 'shell_layer' pins is:
Averaging is needed 'split_shells' 'shell_layer' Expected output
No Not connected/false Not connected Location as in the result file. Fields with all element shapes combined. All shell layers present.
No true Not connected Location as in the result file. Fields split according to element shapes. All shell layers present.
No true Connected Location as in the result file. Fields split according to element shapes. Only the requested shell layer present.
No Not connected/false Connected Location as in the result file. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Not connected Location as requested. Fields split according to element shapes. All shell layers present.
Yes false Not connected Location as requested. Fields with all element shapes combined. All shell layers present.
Yes false Connected Location as requested. Fields with all element shapes combined. Only the requested shell layer present.
Yes Not connected/true Connected Location as requested. Fields split according to element shapes. Only the requested shell layer present.
  • The available 'elshape' values are:
elshape Related elements
1 Shell (generic)
2 Solid
3 Beam
4 Skin
5 Contact
6 Load
7 Point
8 Shell with 1 result across thickness (membrane)
9 Shell with 2 results across thickness (top/bottom)
10 Shell with 3 results across thickness (top/bottom/mid)
11 Gasket
12 Multi-Point Constraint
13 Pretension

Supported file types

  • hdf5: h5dpf
  • mapdl: rst,rth

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 9optional
requested_locationname
(string)expected type(s)

requested location Nodal, Elemental or ElementalNodal

pin 10optional
item_indexname
(int32)expected type(s)

Index of requested item.

pin 22optional
read_beamsname
(bool)expected type(s)

elemental nodal beam results are read if this pin is set to true (default is false)

pin 26optional
split_shellsname
(bool)expected type(s)

If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required.

pin 27optional
shell_layername
(int32)expected type(s)

If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: state_variable
  • full name: result.state_variable
  • internal name: ESV
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.state_variable() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.item_index.Connect(my_item_index)
op.inputs.read_beams.Connect(my_read_beams)
op.inputs.split_shells.Connect(my_split_shells)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.state_variable() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.item_index.connect(my_item_index)
op.inputs.read_beams.connect(my_read_beams)
op.inputs.split_shells.connect(my_split_shells)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ESV"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(10, my_item_index);
op.connect(22, my_read_beams);
op.connect(26, my_split_shells);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: fluid velocity

Description

Read/compute FV by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • mapdl: rst

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 2optional
fields_container (modified inplace)name
(fields_container)expected type(s)

Fields container already allocated modified inplace

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

if true the field is rotated to global coordinate system (default true). Please check your results carefully if 'false' is used for Elemental or ElementalNodal results averaged to the Nodes when adjacent elements do not share the same coordinate system, as results may be incorrect.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: core
  • scripting name: fluid_velocity
  • full name: result.fluid_velocity
  • internal name: FV
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.fluid_velocity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).Connect(my_fields_container (modified inplace))
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.fluid_velocity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container (modified inplace).connect(my_fields_container (modified inplace))
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("FV"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container (modified inplace));
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_bool_rotate_to_global);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: merge supports

Description

Assembles a set of supports into a unique one.

Inputs

pin -200optional
should_merge_named_selectionsname
(bool)expected type(s)

For some result files (such as RST), the scoping on names selection is duplicated through all the distributed files.If this pin is false, the merging process is skipped. If it is true, this scoping is merged. Default is true.

pin 0, 1...requested, ellipsis
supportsname
(vector> | abstract_field_support)expected type(s)

A vector of supports to merge or supports from pin 0 to ...

Outputs

pin 0requested
merged_supportname
(abstract_field_support)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_supports
  • full name: utility.merge_supports
  • internal name: merge::abstract_support
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_supports() # operator instantiation
op.inputs.should_merge_named_selections.Connect(my_should_merge_named_selections)
op.inputs.supports1.Connect(my_supports_1)
op.inputs.supports2.Connect(my_supports_2)
my_merged_support = op.outputs.merged_support.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_supports() # operator instantiation
op.inputs.should_merge_named_selections.connect(my_should_merge_named_selections)
op.inputs.supports1.connect(my_supports_1)
op.inputs.supports2.connect(my_supports_2)
my_merged_support = op.outputs.merged_support()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::abstract_support"); // operator instantiation
op.connect(-200, my_should_merge_named_selections);
op.connect(0, my_supports_1);
op.connect(1, my_supports_2);
ansys::dpf::AbstractFieldSupport my_merged_support = op.getOutput<ansys::dpf::AbstractFieldSupport>(0);

result: global kinetic energy (LSDyna)

Description

Read Global Kinetic Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot,binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_kinetic_energy
  • full name: result.global_kinetic_energy
  • internal name: GLOB_ENG_KE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_kinetic_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_kinetic_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_ENG_KE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global time step (LSDyna)

Description

Read Global Time Step (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_time_step
  • full name: result.global_time_step
  • internal name: GLOB_DT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_time_step() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_time_step() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_DT"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: matrix inverse

Description

Computes the complex matrix inverse for each field in the given fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

fields_container

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: matrix_inverse
  • full name: math.matrix_inverse
  • internal name: inverseOp
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.matrix_inverse() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.matrix_inverse() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("inverseOp"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

geo: cartesian to spherical coordinates

Description

Converts 3D field from cartesian coordinates to spherical coordinates.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: geo
  • plugin: core
  • scripting name: cartesian_to_spherical
  • full name: geo.cartesian_to_spherical
  • internal name: cartesian_to_spherical
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.cartesian_to_spherical() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.cartesian_to_spherical() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("cartesian_to_spherical"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: global rigid body stopper energy (LSDyna)

Description

Read Global Rigid Body Stopper Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_rigid_body_stopper_energy
  • full name: result.global_rigid_body_stopper_energy
  • internal name: GLOB_RBE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_rigid_body_stopper_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_rigid_body_stopper_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_RBE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global spring and damper energy (LSDyna)

Description

Read Global Spring and Damper Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_spring_damper_energy
  • full name: result.global_spring_damper_energy
  • internal name: GLOB_KDE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_spring_damper_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_spring_damper_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_KDE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global hourglass energy (LSDyna)

Description

Read Global Hourglass Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_hourglass_energy
  • full name: result.global_hourglass_energy
  • internal name: GLOB_ENG_AHO
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_hourglass_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_hourglass_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_ENG_AHO"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: beam T bending moment (LSDyna)

Description

Read Beam T Bending Moment (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: beam_t_bending_moment
  • full name: result.beam_t_bending_moment
  • internal name: B_M2
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.beam_t_bending_moment() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.beam_t_bending_moment() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("B_M2"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global system damping energy (LSDyna)

Description

Read Global System Damping Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_system_damping_energy
  • full name: result.global_system_damping_energy
  • internal name: GLOB_DE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_system_damping_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_system_damping_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_DE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global eroded kinetic energy (LSDyna)

Description

Read Global Eroded Kinetic Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_eroded_kinetic_energy
  • full name: result.global_eroded_kinetic_energy
  • internal name: GLOB_ERKE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_eroded_kinetic_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_eroded_kinetic_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_ERKE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global energy ratio (LSDyna)

Description

Read Global Energy Ratio (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_energy_ratio
  • full name: result.global_energy_ratio
  • internal name: GLOB_ER
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_energy_ratio() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_energy_ratio() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_ER"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

mapping: on reduced coordinates

Description

Evaluates a result on specified reduced coordinates of given elements (interpolates results inside elements with shape functions).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
reduced_coordinatesname
(field | fields_container)expected type(s)

coordinates in the reference elements to find (found with the operator "find_reduced_coordinates")

pin 2requested
element_idsname
(scopings_container)expected type(s)

Ids of the elements where each set of reduced coordinates is found (found with the operator "find_reduced_coordinates")

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

if the first field in input has no mesh in support, then the mesh in this pin is expected (default is false), if a meshes container with several meshes is set, it should be on the same label spaces as the coordinates fields container

pin 200optional
use_quadratic_elementsname
(bool)expected type(s)

If this pin is set to true, the interpolation is computed on the quadratic element if the element is quadratic (more precise but less performant). Default is false. To use only when results have mid side nodes values.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mapping
  • plugin: core
  • scripting name: on_reduced_coordinates
  • full name: mapping.on_reduced_coordinates
  • internal name: interpolation_operator
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mapping.on_reduced_coordinates() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.reduced_coordinates.Connect(my_reduced_coordinates)
op.inputs.element_ids.Connect(my_element_ids)
op.inputs.mesh.Connect(my_mesh)
op.inputs.use_quadratic_elements.Connect(my_use_quadratic_elements)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mapping.on_reduced_coordinates() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.reduced_coordinates.connect(my_reduced_coordinates)
op.inputs.element_ids.connect(my_element_ids)
op.inputs.mesh.connect(my_mesh)
op.inputs.use_quadratic_elements.connect(my_use_quadratic_elements)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("interpolation_operator"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_reduced_coordinates);
op.connect(2, my_element_ids);
op.connect(7, my_mesh);
op.connect(200, my_use_quadratic_elements);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global added mass (LSDyna)

Description

Read Global Added Mass (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_added_mass
  • full name: result.global_added_mass
  • internal name: GLOB_AM
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_added_mass() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_added_mass() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_AM"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

invariant: principal invariants (fields container)

Description

Computes the element-wise Eigen values of all the tensor fields of a fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_eig_1name
(fields_container)expected type(s)

first eigen value fields

pin 1requested
fields_eig_2name
(fields_container)expected type(s)

second eigen value fields

pin 2requested
fields_eig_3name
(fields_container)expected type(s)

third eigen value fields

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: invariant
  • plugin: core
  • scripting name: principal_invariants_fc
  • full name: invariant.principal_invariants_fc
  • internal name: invariants_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.principal_invariants_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_eig_1 = op.outputs.fields_eig_1.GetData()
my_fields_eig_2 = op.outputs.fields_eig_2.GetData()
my_fields_eig_3 = op.outputs.fields_eig_3.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.principal_invariants_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_eig_1 = op.outputs.fields_eig_1()
my_fields_eig_2 = op.outputs.fields_eig_2()
my_fields_eig_3 = op.outputs.fields_eig_3()
#include "dpf_api.h"

ansys::dpf::Operator op("invariants_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_eig_1 = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_fields_eig_2 = op.getOutput<ansys::dpf::FieldsContainer>(1);
ansys::dpf::FieldsContainer my_fields_eig_3 = op.getOutput<ansys::dpf::FieldsContainer>(2);

result: global added mass (percentage) (LSDyna)

Description

Read Global Added Mass (percentage) (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_added_mass_pct
  • full name: result.global_added_mass_pct
  • internal name: GLOB_AMP
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_added_mass_pct() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_added_mass_pct() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_AMP"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: global center of mass (LSDyna)

Description

Read Global Center of Mass (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: global_center_mass
  • full name: result.global_center_mass
  • internal name: GLOB_XCM
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.global_center_mass() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.global_center_mass() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("GLOB_XCM"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: beam S shear force (LSDyna)

Description

Read Beam S Shear Force (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: beam_s_shear_force
  • full name: result.beam_s_shear_force
  • internal name: B_T1
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.beam_s_shear_force() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.beam_s_shear_force() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("B_T1"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: beam S bending moment (LSDyna)

Description

Read Beam S Bending Moment (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: beam_s_bending_moment
  • full name: result.beam_s_bending_moment
  • internal name: B_M1
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.beam_s_bending_moment() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.beam_s_bending_moment() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("B_M1"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: operator changelog

Description

Return a GenericDataContainer used to instantiate the Changelog of an operator based on its name.

Inputs

pin 0requested
operator_namename
(string)expected type(s)

Operator internal name.

Outputs

pin 0requested
changelog_gdcname
(generic_data_container)expected type(s)

GenericDataContainer used to instantiate a Changelog.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: operator_changelog
  • full name: utility.operator_changelog
  • internal name: operator_changelog
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.operator_changelog() # operator instantiation
op.inputs.operator_name.Connect(my_operator_name)
my_changelog_gdc = op.outputs.changelog_gdc.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.operator_changelog() # operator instantiation
op.inputs.operator_name.connect(my_operator_name)
my_changelog_gdc = op.outputs.changelog_gdc()
#include "dpf_api.h"

ansys::dpf::Operator op("operator_changelog"); // operator instantiation
op.connect(0, my_operator_name);
ansys::dpf::GenericDataContainer my_changelog_gdc = op.getOutput<ansys::dpf::GenericDataContainer>(0);

result: beam RS shear stress (LSDyna)

Description

Read Beam RS Shear Stress (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
integration_pointname
(int32)expected type(s)

integration point where the result will be read from. Default value: 0 (first integration point).

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: beam_rs_shear_stress
  • full name: result.beam_rs_shear_stress
  • internal name: B_ST1
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.beam_rs_shear_stress() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.integration_point.Connect(my_integration_point)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.beam_rs_shear_stress() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.integration_point.connect(my_integration_point)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("B_ST1"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_integration_point);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: part eroded internal energy (LSDyna)

Description

Read Part Eroded Internal Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
entity_scopingname
(scoping)expected type(s)

entity (part for matsum, interface for rcforc) where the result will be scoped

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: part_eroded_internal_energy
  • full name: result.part_eroded_internal_energy
  • internal name: M_ERIE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.part_eroded_internal_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.entity_scoping.Connect(my_entity_scoping)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.part_eroded_internal_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.entity_scoping.connect(my_entity_scoping)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("M_ERIE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_entity_scoping);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: part kinetic energy (LSDyna)

Description

Read Part Kinetic Energy (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
entity_scopingname
(scoping)expected type(s)

entity (part for matsum, interface for rcforc) where the result will be scoped

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: part_kinetic_energy
  • full name: result.part_kinetic_energy
  • internal name: M_KE
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.part_kinetic_energy() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.entity_scoping.Connect(my_entity_scoping)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.part_kinetic_energy() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.entity_scoping.connect(my_entity_scoping)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("M_KE"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_entity_scoping);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

scoping: on mesh property

Description

Provides a scoping on a given property name and a property number.

Inputs

pin 0optional
requested_locationname
(string)expected type(s)

Nodal or Elemental location are expected

pin 1requested
property_namename
(string)expected type(s)

ex "apdl_element_type", "elprops", "mat", "eltype", "connectivity", "shell_elements", "solid_elements", "skin_elements", "beam_elements", "point_elements"...

pin 2optional
property_idname
(vector | int32)expected type(s)
pin 5optional
inclusivename
(int32)expected type(s)

Default is 1 (inclusive is true). Only used if 'shape_values' property is requested. If inclusive is set to 1 and 'elprops' property field is available, it will select all elements that are set on the corresponding property. If inclusive is set to 0 (exclusive) and 'elprops' property field is available, it will select the elements that are only set on this property.

pin 7requested
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
mesh_scopingname
(scoping)expected type(s)

Scoping

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: on_mesh_property
  • full name: scoping.on_mesh_property
  • internal name: meshscoping_provider_by_prop
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.on_mesh_property() # operator instantiation
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.property_name.Connect(my_property_name)
op.inputs.property_id.Connect(my_property_id)
op.inputs.inclusive.Connect(my_inclusive)
op.inputs.mesh.Connect(my_mesh)
my_mesh_scoping = op.outputs.mesh_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.on_mesh_property() # operator instantiation
op.inputs.requested_location.connect(my_requested_location)
op.inputs.property_name.connect(my_property_name)
op.inputs.property_id.connect(my_property_id)
op.inputs.inclusive.connect(my_inclusive)
op.inputs.mesh.connect(my_mesh)
my_mesh_scoping = op.outputs.mesh_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("meshscoping_provider_by_prop"); // operator instantiation
op.connect(0, my_requested_location);
op.connect(1, my_property_name);
op.connect(2, my_property_id);
op.connect(5, my_inclusive);
op.connect(7, my_mesh);
ansys::dpf::Scoping my_mesh_scoping = op.getOutput<ansys::dpf::Scoping>(0);

scoping: from mesh

Description

Provides the entire mesh scoping based on the requested location

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)
pin 1optional
requested_locationname
(string)expected type(s)

if nothing the operator returns the nodes scoping, possible locations are: Nodal(default) or Elemental

Outputs

pin 0requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: from_mesh
  • full name: scoping.from_mesh
  • internal name: MeshScopingProvider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.from_mesh() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.from_mesh() # operator instantiation
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("MeshScopingProvider"); // operator instantiation
op.connect(0, my_mesh);
op.connect(1, my_requested_location);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(0);

result: part added mass (LSDyna)

Description

Read Part Added Mass (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
entity_scopingname
(scoping)expected type(s)

entity (part for matsum, interface for rcforc) where the result will be scoped

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: part_added_mass
  • full name: result.part_added_mass
  • internal name: M_ENG_AM
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.part_added_mass() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.entity_scoping.Connect(my_entity_scoping)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.part_added_mass() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.entity_scoping.connect(my_entity_scoping)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("M_ENG_AM"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_entity_scoping);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: part rigid body velocity (LSDyna)

Description

Read Part Rigid Body Velocity (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
entity_scopingname
(scoping)expected type(s)

entity (part for matsum, interface for rcforc) where the result will be scoped

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: part_rigid_body_velocity
  • full name: result.part_rigid_body_velocity
  • internal name: M_RBV
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.part_rigid_body_velocity() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.entity_scoping.Connect(my_entity_scoping)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.part_rigid_body_velocity() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.entity_scoping.connect(my_entity_scoping)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("M_RBV"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_entity_scoping);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

min_max: time of max

Description

Evaluates time/frequency of maximum.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 3optional
abs_valuename
(bool)expected type(s)

Should use absolute value.

pin 4optional
compute_amplitudename
(bool)expected type(s)

Do calculate amplitude.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

incrementalThis operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
(bool)expected type(s)
truedefault value
: This operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: time_of_max_by_entity
  • full name: min_max.time_of_max_by_entity
  • internal name: time_of_max_by_entity
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.time_of_max_by_entity() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.abs_value.Connect(my_abs_value)
op.inputs.compute_amplitude.Connect(my_compute_amplitude)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.time_of_max_by_entity() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.abs_value.connect(my_abs_value)
op.inputs.compute_amplitude.connect(my_compute_amplitude)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("time_of_max_by_entity"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(3, my_abs_value);
op.connect(4, my_compute_amplitude);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: interface contact force (LSDyna)

Description

Read Interface Contact Force (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
entity_scopingname
(scoping)expected type(s)

entity (part for matsum, interface for rcforc) where the result will be scoped

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: interface_contact_force
  • full name: result.interface_contact_force
  • internal name: R_CF
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.interface_contact_force() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.entity_scoping.Connect(my_entity_scoping)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.interface_contact_force() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.entity_scoping.connect(my_entity_scoping)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("R_CF"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_entity_scoping);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: interface resultant contact force (LSDyna)

Description

Read Interface Resultant Contact Force (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
entity_scopingname
(scoping)expected type(s)

entity (part for matsum, interface for rcforc) where the result will be scoped

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: interface_resultant_contact_force
  • full name: result.interface_resultant_contact_force
  • internal name: R_CFR
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.interface_resultant_contact_force() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.entity_scoping.Connect(my_entity_scoping)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.interface_resultant_contact_force() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.entity_scoping.connect(my_entity_scoping)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("R_CFR"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_entity_scoping);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: interface contact moment (LSDyna)

Description

Read Interface Contact Moment (LSDyna) by calling the readers defined by the datasources.

Supported file types

  • hdf5: h5dpf
  • lsdyna: binout

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 6optional
entity_scopingname
(scoping)expected type(s)

entity (part for matsum, interface for rcforc) where the result will be scoped

pin 50optional
unit_systemname
(int32 | string | class dataProcessing::unit::CUnitSystem)expected type(s)

Unit System ID (int), semicolon-separated list of base unit strings (str) or UnitSystem instance

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: interface_contact_moment
  • full name: result.interface_contact_moment
  • internal name: R_CM
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.interface_contact_moment() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.entity_scoping.Connect(my_entity_scoping)
op.inputs.unit_system.Connect(my_unit_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.interface_contact_moment() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.entity_scoping.connect(my_entity_scoping)
op.inputs.unit_system.connect(my_unit_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("R_CM"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_entity_scoping);
op.connect(50, my_unit_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: density

Description

Read Density by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: density
  • full name: result.density
  • internal name: RHO
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.density() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.density() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("RHO"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: spectrum data

Description

Read spectral data from the result files contained in the streams or data sources.

Supported file types

  • mapdl: mode,prs

Inputs

pin 3optional
streamsname
(streams_container)expected type(s)

Result file container allowed to be kept open to cache data.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Result file path container, used if no streams are set.

Outputs

pin 0requested
participation_factorsname
(fields_container)expected type(s)

Fields container holding participation factors.

pin 1requested
mode_coefficientsname
(fields_container)expected type(s)

Fields container holding mode coefficients (PRS File).

pin 2requested
damping_ratiosname
(fields_container)expected type(s)

Fields container holding damping ratios (PRS File).

pin 3requested
global_dampingname
(fields_container)expected type(s)

Fields container holding for each spectrum: Global Damping Ratio, Damping Stiffness Coefficient & Damping Mass Coefficient (PRS File).

pin 4requested
missing_massname
(fields_container)expected type(s)

Fields container holding for each spectrum: Missing Mass Mode (0: None, 1: Active), Missing Mass Effect ZPA (PRS File).

pin 5requested
rigid_responsename
(fields_container)expected type(s)

Fields container holding for each spectrum: Rigid Response Mode (0: None, 1: Gupta, 2: Lindley), Freq Begin (Gupta) / ZPA (Lindley), Freq End (Gupta) (PRS File).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: spectrum_data
  • full name: result.spectrum_data
  • internal name: spectrum_data
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.spectrum_data() # operator instantiation
op.inputs.streams.Connect(my_streams)
op.inputs.data_sources.Connect(my_data_sources)
my_participation_factors = op.outputs.participation_factors.GetData()
my_mode_coefficients = op.outputs.mode_coefficients.GetData()
my_damping_ratios = op.outputs.damping_ratios.GetData()
my_global_damping = op.outputs.global_damping.GetData()
my_missing_mass = op.outputs.missing_mass.GetData()
my_rigid_response = op.outputs.rigid_response.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.spectrum_data() # operator instantiation
op.inputs.streams.connect(my_streams)
op.inputs.data_sources.connect(my_data_sources)
my_participation_factors = op.outputs.participation_factors()
my_mode_coefficients = op.outputs.mode_coefficients()
my_damping_ratios = op.outputs.damping_ratios()
my_global_damping = op.outputs.global_damping()
my_missing_mass = op.outputs.missing_mass()
my_rigid_response = op.outputs.rigid_response()
#include "dpf_api.h"

ansys::dpf::Operator op("spectrum_data"); // operator instantiation
op.connect(3, my_streams);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_participation_factors = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_mode_coefficients = op.getOutput<ansys::dpf::FieldsContainer>(1);
ansys::dpf::FieldsContainer my_damping_ratios = op.getOutput<ansys::dpf::FieldsContainer>(2);
ansys::dpf::FieldsContainer my_global_damping = op.getOutput<ansys::dpf::FieldsContainer>(3);
ansys::dpf::FieldsContainer my_missing_mass = op.getOutput<ansys::dpf::FieldsContainer>(4);
ansys::dpf::FieldsContainer my_rigid_response = op.getOutput<ansys::dpf::FieldsContainer>(5);

averaging: elemental to elemental nodal (fields container)

Description

Transforms Elemental field to Elemental Nodal field.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
meshname
(abstract_meshed_region)expected type(s)
pin 3optional
mesh_scopingname
(scoping)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: elemental_to_elemental_nodal_fc
  • full name: averaging.elemental_to_elemental_nodal_fc
  • internal name: elemental_to_elemental_nodal_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.elemental_to_elemental_nodal_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.elemental_to_elemental_nodal_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("elemental_to_elemental_nodal_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(3, my_mesh_scoping);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: total pressure

Description

Read Total Pressure by calling the readers defined by the datasources.

Supported file types

  • cff: flprj,cas

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: total_pressure
  • full name: result.total_pressure
  • internal name: P_TOT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.total_pressure() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.total_pressure() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("P_TOT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: mean velocity

Description

Read Mean Velocity by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: mean_velocity
  • full name: result.mean_velocity
  • internal name: V_A
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mean_velocity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mean_velocity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("V_A"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: Lighthill tensor divergence

Description

Read Divergence of the Lighthill Tensor by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: div_lighthill_tensor
  • full name: result.div_lighthill_tensor
  • internal name: SV_RTDFT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.div_lighthill_tensor() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.div_lighthill_tensor() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("SV_RTDFT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: mass flow rate

Description

Read Mass Flow Rate by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: mass_flow_rate
  • full name: result.mass_flow_rate
  • internal name: MDOT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mass_flow_rate() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mass_flow_rate() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MDOT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: mach number

Description

Read Mach Number by calling the readers defined by the datasources.

Supported file types

  • cff: flprj,cas

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: mach_number
  • full name: result.mach_number
  • internal name: MACH
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mach_number() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mach_number() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("MACH"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: rms temperature

Description

Read RMS Temperature by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: rms_temperature
  • full name: result.rms_temperature
  • internal name: TEMP_RMS
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.rms_temperature() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.rms_temperature() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("TEMP_RMS"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

scoping: scoping get attribute

Description

Uses the Scoping APIs to return a given attribute of the scoping in input.

Inputs

pin 0requested
scopingname
(scoping)expected type(s)
pin 1requested
property_namename
(string)expected type(s)

Supported property names are: "ids", "location".

Outputs

pin 0requested
propertyname
(vector | string)expected type(s)

Returns a vector of int for property: "ids" and a string for property: "location".

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: scoping_get_attribute
  • full name: scoping.scoping_get_attribute
  • internal name: scoping::get_attribute
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.scoping_get_attribute() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.property_name.Connect(my_property_name)
my_property = op.outputs.property.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.scoping_get_attribute() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.property_name.connect(my_property_name)
my_property = op.outputs.property()
#include "dpf_api.h"

ansys::dpf::Operator op("scoping::get_attribute"); // operator instantiation
op.connect(0, my_scoping);
op.connect(1, my_property_name);
std::vector my_property = op.getOutput<std::vector>(0);

result: read cms_rbd file

Description

Read the invariant terms and the model data from a cms_rbd file

Inputs

pin 0requested
in_cms_rbd_file_pathname
(string)expected type(s)

file name with cms_rbd extension where to read the input cms_rbd file.

Outputs

pin 0requested
model_dataname
(property_field)expected type(s)

data describing the finite element model

pin 1requested
center_of_massname
(field)expected type(s)

center of mass of the body

pin 2requested
inertia_reliefname
(field)expected type(s)

inertia matrix

pin 3requested
model_sizename
(property_field)expected type(s)
pin 4requested
master_node_coordinatesname
(vector)expected type(s)
pin 5requested
v_trsfname
(vector)expected type(s)

translational and rotational shape functions

pin 6requested
k_matname
(field)expected type(s)
pin 7requested
mass_matname
(field)expected type(s)
pin 8requested
c_matname
(field)expected type(s)
pin 9requested
rhsname
(field)expected type(s)
pin 10requested
dnname
(vector)expected type(s)
pin 11requested
dr_cross_nname
(vector)expected type(s)
pin 12requested
drnname
(vector)expected type(s)
pin 13requested
dn_cross_nname
(vector)expected type(s)
pin 14requested
dnx_yname
(vector)expected type(s)
pin 15requested
dny_yname
(vector)expected type(s)
pin 16requested
dnz_yname
(vector)expected type(s)
pin 17requested
dyx_nname
(vector)expected type(s)
pin 18requested
dyy_nname
(vector)expected type(s)
pin 19requested
dyz_nname
(vector)expected type(s)
pin 20requested
dnxnname
(vector)expected type(s)
pin 21requested
dnynname
(vector)expected type(s)
pin 22requested
dnznname
(vector)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: read_cms_rbd_file
  • full name: result.read_cms_rbd_file
  • internal name: read_cms_rbd_file
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.read_cms_rbd_file() # operator instantiation
op.inputs.in_cms_rbd_file_path.Connect(my_in_cms_rbd_file_path)
my_model_data = op.outputs.model_data.GetData()
my_center_of_mass = op.outputs.center_of_mass.GetData()
my_inertia_relief = op.outputs.inertia_relief.GetData()
my_model_size = op.outputs.model_size.GetData()
my_master_node_coordinates = op.outputs.master_node_coordinates.GetData()
my_v_trsf = op.outputs.v_trsf.GetData()
my_k_mat = op.outputs.k_mat.GetData()
my_mass_mat = op.outputs.mass_mat.GetData()
my_c_mat = op.outputs.c_mat.GetData()
my_rhs = op.outputs.rhs.GetData()
my_dn = op.outputs.dn.GetData()
my_dr_cross_n = op.outputs.dr_cross_n.GetData()
my_drn = op.outputs.drn.GetData()
my_dn_cross_n = op.outputs.dn_cross_n.GetData()
my_dnx_y = op.outputs.dnx_y.GetData()
my_dny_y = op.outputs.dny_y.GetData()
my_dnz_y = op.outputs.dnz_y.GetData()
my_dyx_n = op.outputs.dyx_n.GetData()
my_dyy_n = op.outputs.dyy_n.GetData()
my_dyz_n = op.outputs.dyz_n.GetData()
my_dnxn = op.outputs.dnxn.GetData()
my_dnyn = op.outputs.dnyn.GetData()
my_dnzn = op.outputs.dnzn.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.read_cms_rbd_file() # operator instantiation
op.inputs.in_cms_rbd_file_path.connect(my_in_cms_rbd_file_path)
my_model_data = op.outputs.model_data()
my_center_of_mass = op.outputs.center_of_mass()
my_inertia_relief = op.outputs.inertia_relief()
my_model_size = op.outputs.model_size()
my_master_node_coordinates = op.outputs.master_node_coordinates()
my_v_trsf = op.outputs.v_trsf()
my_k_mat = op.outputs.k_mat()
my_mass_mat = op.outputs.mass_mat()
my_c_mat = op.outputs.c_mat()
my_rhs = op.outputs.rhs()
my_dn = op.outputs.dn()
my_dr_cross_n = op.outputs.dr_cross_n()
my_drn = op.outputs.drn()
my_dn_cross_n = op.outputs.dn_cross_n()
my_dnx_y = op.outputs.dnx_y()
my_dny_y = op.outputs.dny_y()
my_dnz_y = op.outputs.dnz_y()
my_dyx_n = op.outputs.dyx_n()
my_dyy_n = op.outputs.dyy_n()
my_dyz_n = op.outputs.dyz_n()
my_dnxn = op.outputs.dnxn()
my_dnyn = op.outputs.dnyn()
my_dnzn = op.outputs.dnzn()
#include "dpf_api.h"

ansys::dpf::Operator op("read_cms_rbd_file"); // operator instantiation
op.connect(0, my_in_cms_rbd_file_path);
ansys::dpf::PropertyField my_model_data = op.getOutput<ansys::dpf::PropertyField>(0);
ansys::dpf::Field my_center_of_mass = op.getOutput<ansys::dpf::Field>(1);
ansys::dpf::Field my_inertia_relief = op.getOutput<ansys::dpf::Field>(2);
ansys::dpf::PropertyField my_model_size = op.getOutput<ansys::dpf::PropertyField>(3);
std::vector my_master_node_coordinates = op.getOutput<std::vector>(4);
std::vector my_v_trsf = op.getOutput<std::vector>(5);
ansys::dpf::Field my_k_mat = op.getOutput<ansys::dpf::Field>(6);
ansys::dpf::Field my_mass_mat = op.getOutput<ansys::dpf::Field>(7);
ansys::dpf::Field my_c_mat = op.getOutput<ansys::dpf::Field>(8);
ansys::dpf::Field my_rhs = op.getOutput<ansys::dpf::Field>(9);
std::vector my_dn = op.getOutput<std::vector>(10);
std::vector my_dr_cross_n = op.getOutput<std::vector>(11);
std::vector my_drn = op.getOutput<std::vector>(12);
std::vector my_dn_cross_n = op.getOutput<std::vector>(13);
std::vector my_dnx_y = op.getOutput<std::vector>(14);
std::vector my_dny_y = op.getOutput<std::vector>(15);
std::vector my_dnz_y = op.getOutput<std::vector>(16);
std::vector my_dyx_n = op.getOutput<std::vector>(17);
std::vector my_dyy_n = op.getOutput<std::vector>(18);
std::vector my_dyz_n = op.getOutput<std::vector>(19);
std::vector my_dnxn = op.getOutput<std::vector>(20);
std::vector my_dnyn = op.getOutput<std::vector>(21);
std::vector my_dnzn = op.getOutput<std::vector>(22);

result: mean temperature

Description

Read Mean Temperature by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: mean_temperature
  • full name: result.mean_temperature
  • internal name: TEMP_A
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mean_temperature() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mean_temperature() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("TEMP_A"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

min_max: over fields container

Description

Compute the component-wise minimum (out 0) and maximum (out 1) over a fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
field_minname
(field)expected type(s)
pin 1requested
field_maxname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: min_max_fc
  • full name: min_max.min_max_fc
  • internal name: min_max_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.min_max_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_field_min = op.outputs.field_min.GetData()
my_field_max = op.outputs.field_max.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.min_max_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_field_min = op.outputs.field_min()
my_field_max = op.outputs.field_max()
#include "dpf_api.h"

ansys::dpf::Operator op("min_max_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::Field my_field_min = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_field_max = op.getOutput<ansys::dpf::Field>(1);

result: surface heat rate

Description

Read Surface Heat Rate by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: surface_heat_rate
  • full name: result.surface_heat_rate
  • internal name: Q
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.surface_heat_rate() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.surface_heat_rate() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("Q"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: extract scoping

Description

Takes a field or a fields container and extracts its scoping or scopings container.

Inputs

pin 0optional
field_or_fields_containername
(field | fields_container)expected type(s)

Outputs

pin 0requested
mesh_scopingname
(scoping | scopings_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: extract_scoping
  • full name: utility.extract_scoping
  • internal name: extract_scoping
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.extract_scoping() # operator instantiation
op.inputs.field_or_fields_container.Connect(my_field_or_fields_container)
my_mesh_scoping = op.outputs.mesh_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.extract_scoping() # operator instantiation
op.inputs.field_or_fields_container.connect(my_field_or_fields_container)
my_mesh_scoping = op.outputs.mesh_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("extract_scoping"); // operator instantiation
op.connect(0, my_field_or_fields_container);
ansys::dpf::Scoping my_mesh_scoping = op.getOutput<ansys::dpf::Scoping>(0);

result: thermal conductivity

Description

Read Thermal Conductivity by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: thermal_conductivity
  • full name: result.thermal_conductivity
  • internal name: KT
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.thermal_conductivity() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.thermal_conductivity() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("KT"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: specific heat

Description

Read Specific Heat by calling the readers defined by the datasources.

Supported file types

  • cff: cas,flprj

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: specific_heat
  • full name: result.specific_heat
  • internal name: CP
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.specific_heat() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.specific_heat() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("CP"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

logic: enrich materials

Description

Takes a MaterialContainer and a stream and enriches the MaterialContainer using stream data.

Inputs

pin 0requested
MaterialContainername
pin 1requested
streamsname
(streams_container | fields_container)expected type(s)
pin 2requested
streams_mappingname
(property_fields_container)expected type(s)

Outputs

pin 0requested
MaterialContainername
(bool)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: enrich_materials
  • full name: logic.enrich_materials
  • internal name: enrich_materials
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.enrich_materials() # operator instantiation
op.inputs.MaterialContainer.Connect(my_MaterialContainer)
op.inputs.streams.Connect(my_streams)
op.inputs.streams_mapping.Connect(my_streams_mapping)
my_MaterialContainer = op.outputs.MaterialContainer.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.enrich_materials() # operator instantiation
op.inputs.MaterialContainer.connect(my_MaterialContainer)
op.inputs.streams.connect(my_streams)
op.inputs.streams_mapping.connect(my_streams_mapping)
my_MaterialContainer = op.outputs.MaterialContainer()
#include "dpf_api.h"

ansys::dpf::Operator op("enrich_materials"); // operator instantiation
op.connect(0, my_MaterialContainer);
op.connect(1, my_streams);
op.connect(2, my_streams_mapping);
bool my_MaterialContainer = op.getOutput<bool>(0);

result: turbulent dissipation rate (epsilon)

Description

Read Turbulent Dissipation Rate (epsilon) by calling the readers defined by the datasources.

Supported file types

  • cff: flprj,cas

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.

pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)

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

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the result files

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

pin 1000, 1001...optional, ellipsis
qualifiersname
(label_space)expected type(s)

(for Fluid results only) LabelSpace with combination of zone, phases or species ids

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: epsilon
  • full name: result.epsilon
  • internal name: EPS
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.epsilon() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.region_scoping.Connect(my_region_scoping)
op.inputs.qualifiers1.Connect(my_qualifiers_1)
op.inputs.qualifiers2.Connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.epsilon() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.region_scoping.connect(my_region_scoping)
op.inputs.qualifiers1.connect(my_qualifiers_1)
op.inputs.qualifiers2.connect(my_qualifiers_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("EPS"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(25, my_region_scoping);
op.connect(1000, my_qualifiers_1);
op.connect(1001, my_qualifiers_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

metadata: time freq provider

Description

Reads the time/frequency support from the results files contained in the streams or data sources.

Supported file types

  • cff: cas,flprj
  • cgns: cgns
  • hdf5: h5dpf
  • lsdyna: d3ssd,d3atv,d3acs,d3acp,lsda,d3plot,d3psd,binout,moddynout
  • mapdl: rfrq,rdsp,cms,mode,rst,rth,dsub

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

streams (result file container) (optional)

pin 4requested
data_sourcesname
(data_sources)expected type(s)

If the stream is null, retrieves the file path from the data sources.

Outputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: time_freq_provider
  • full name: metadata.time_freq_provider
  • internal name: time_freq_support_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.time_freq_provider() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_time_freq_support = op.outputs.time_freq_support.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.time_freq_provider() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_time_freq_support = op.outputs.time_freq_support()
#include "dpf_api.h"

ansys::dpf::Operator op("time_freq_support_provider"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::TimeFreqSupport my_time_freq_support = op.getOutput<ansys::dpf::TimeFreqSupport>(0);

metadata: mesh info provider

Description

Reads the mesh information, such as number of elements (common property), number of faces (Cff plugins) or scoping of parts (LSDYNA plugins) on files contained in the streams or data sources.

Supported file types

  • cff: flprj,cas
  • cgns: cgns
  • lsdyna: d3plot

Inputs

pin 0optional
time_scopingname
(int32)expected type(s)

Optional time/frequency set ID of the mesh.

pin 3optional
streams_containername
(streams_container)expected type(s)

streams (mesh file container) (optional)

pin 4requested
data_sourcesname
(data_sources)expected type(s)

If the stream is null, retrieves the file path from the data sources.

Outputs

pin 0requested
mesh_infoname
(generic_data_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: mesh_info_provider
  • full name: metadata.mesh_info_provider
  • internal name: mesh_info_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.mesh_info_provider() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_mesh_info = op.outputs.mesh_info.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.mesh_info_provider() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_mesh_info = op.outputs.mesh_info()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh_info_provider"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::GenericDataContainer my_mesh_info = op.getOutput<ansys::dpf::GenericDataContainer>(0);

metadata: streams provider

Description

Creates streams (files with cache) from the data sources.

Inputs

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
streams_containername
(streams_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: streams_provider
  • full name: metadata.streams_provider
  • internal name: stream_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.streams_provider() # operator instantiation
op.inputs.data_sources.Connect(my_data_sources)
my_streams_container = op.outputs.streams_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.streams_provider() # operator instantiation
op.inputs.data_sources.connect(my_data_sources)
my_streams_container = op.outputs.streams_container()
#include "dpf_api.h"

ansys::dpf::Operator op("stream_provider"); // operator instantiation
op.connect(4, my_data_sources);
ansys::dpf::Streams my_streams_container = op.getOutput<ansys::dpf::Streams>(0);

result: poynting vector surface

Description

Compute the Poynting Vector surface integral

Inputs

pin 0requested
fields_containerAname
(fields_container)expected type(s)
pin 1requested
fields_containerBname
(fields_container)expected type(s)
pin 2requested
fields_containerCname
(fields_container)expected type(s)
pin 3requested
fields_containerDname
(fields_container)expected type(s)
pin 4optional
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

the mesh region in this pin have to be boundary or skin mesh

pin 5optional
int32name
(int32)expected type(s)

load step number, if it's specified, the Poynting Vector is computed only on the substeps of this step

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: poynting_vector_surface
  • full name: result.poynting_vector_surface
  • internal name: PoyntingVectorSurface
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.poynting_vector_surface() # operator instantiation
op.inputs.fields_containerA.Connect(my_fields_containerA)
op.inputs.fields_containerB.Connect(my_fields_containerB)
op.inputs.fields_containerC.Connect(my_fields_containerC)
op.inputs.fields_containerD.Connect(my_fields_containerD)
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.int32.Connect(my_int32)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.poynting_vector_surface() # operator instantiation
op.inputs.fields_containerA.connect(my_fields_containerA)
op.inputs.fields_containerB.connect(my_fields_containerB)
op.inputs.fields_containerC.connect(my_fields_containerC)
op.inputs.fields_containerD.connect(my_fields_containerD)
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.int32.connect(my_int32)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("PoyntingVectorSurface"); // operator instantiation
op.connect(0, my_fields_containerA);
op.connect(1, my_fields_containerB);
op.connect(2, my_fields_containerC);
op.connect(3, my_fields_containerD);
op.connect(4, my_abstract_meshed_region);
op.connect(5, my_int32);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

metadata: datasources provider

Description

Creates a DataSources by expanding another.

Inputs

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
data_sourcesname
(data_sources)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: datasources_provider
  • full name: metadata.datasources_provider
  • internal name: datasources_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.datasources_provider() # operator instantiation
op.inputs.data_sources.Connect(my_data_sources)
my_data_sources = op.outputs.data_sources.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.datasources_provider() # operator instantiation
op.inputs.data_sources.connect(my_data_sources)
my_data_sources = op.outputs.data_sources()
#include "dpf_api.h"

ansys::dpf::Operator op("datasources_provider"); // operator instantiation
op.connect(4, my_data_sources);
ansys::dpf::DataSources my_data_sources = op.getOutput<ansys::dpf::DataSources>(0);

filter: low pass (timescoping)

Description

The low pass filter returns all the values below (but not equal to) the threshold value in input.

Inputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1requested
thresholdname
(double | field)expected type(s)

a threshold scalar or a field containing one value is expected

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: timescoping_low_pass
  • full name: filter.timescoping_low_pass
  • internal name: core::timescoping::low_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.timescoping_low_pass() # operator instantiation
op.inputs.time_freq_support.Connect(my_time_freq_support)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.timescoping_low_pass() # operator instantiation
op.inputs.time_freq_support.connect(my_time_freq_support)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("core::timescoping::low_pass"); // operator instantiation
op.connect(0, my_time_freq_support);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(0);

scoping: rescope

Description

Rescopes a field on the given scoping. If an ID does not exist in the original field, the default value (in 2) is used when defined.

Inputs

pin 0requested
fieldsname
(fields_container | field)expected type(s)
pin 1optional
mesh_scopingname
(scoping | vector)expected type(s)
pin 2optional
default_valuename
(double | vector)expected type(s)

If pin 2 is used, the IDs not found in the field are added with this default value.

Outputs

pin 0requested
fieldsname
(fields_container | field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: rescope
  • full name: scoping.rescope
  • internal name: Rescope
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.rescope() # operator instantiation
op.inputs.fields.Connect(my_fields)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.default_value.Connect(my_default_value)
my_fields = op.outputs.fields.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.rescope() # operator instantiation
op.inputs.fields.connect(my_fields)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.default_value.connect(my_default_value)
my_fields = op.outputs.fields()
#include "dpf_api.h"

ansys::dpf::Operator op("Rescope"); // operator instantiation
op.connect(0, my_fields);
op.connect(1, my_mesh_scoping);
op.connect(2, my_default_value);
ansys::dpf::FieldsContainer my_fields = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: data sources get attribute

Description

A DataSources in pin 0 and a property name (string) in pin 1 are expected in input. An index refering to the property can also be provided.

Inputs

pin 0requested
data_sourcesname
(data_sources)expected type(s)
pin 1requested
property_namename
(string)expected type(s)

Accepted inputs are: 'file_path' (returns string), 'result_file_name' (returns string), 'domain_file_path' (returns string), 'domain_result_file_name' (returns string), 'num_keys' (returns int), num_result_key (returns int), num_file_path (returns int), 'num_result_file_path' (returns int), 'key_by_index' (returns string), 'result_key_by_index' (returns string), 'path_by_index' (returns string), 'path_key_by_index' (returns string).

pin 2optional
property_indexname
(int32)expected type(s)

Index for the property. Must be set for 'domain_file_path', 'domain_result_file_name' 'key_by_index', 'result_key_by_index', 'path_by_index' and 'path_key_by_index' properties.

pin 3optional
property_keyname
(string)expected type(s)

Key to look for. Must be set for 'file_path' and 'domain_file_path' properties.

pin 4optional
property_result_keyname
(string)expected type(s)

Result key to look for. Can be used for 'file_path', 'result_file_name', 'domain_file_path' and 'domain_result_file_name'.

Outputs

pin 0requested
propertyname
(string | int32)expected type(s)

Property value.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: ds_get_attribute
  • full name: utility.ds_get_attribute
  • internal name: datasources::get_attribute
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.ds_get_attribute() # operator instantiation
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.property_name.Connect(my_property_name)
op.inputs.property_index.Connect(my_property_index)
op.inputs.property_key.Connect(my_property_key)
op.inputs.property_result_key.Connect(my_property_result_key)
my_property = op.outputs.property.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.ds_get_attribute() # operator instantiation
op.inputs.data_sources.connect(my_data_sources)
op.inputs.property_name.connect(my_property_name)
op.inputs.property_index.connect(my_property_index)
op.inputs.property_key.connect(my_property_key)
op.inputs.property_result_key.connect(my_property_result_key)
my_property = op.outputs.property()
#include "dpf_api.h"

ansys::dpf::Operator op("datasources::get_attribute"); // operator instantiation
op.connect(0, my_data_sources);
op.connect(1, my_property_name);
op.connect(2, my_property_index);
op.connect(3, my_property_key);
op.connect(4, my_property_result_key);
std::string my_property = op.getOutput<std::string>(0);

mesh: meshes provider

Description

Reads meshes from result files. Meshes can be spatially or temporally varying.

Supported file types

  • cff: flprj,cas
  • cgns: cgns
  • hdf5: h5dpf
  • lsdyna: d3acp,binout,moddynout,d3acs,d3atv,d3psd,d3plot,d3ssd,d3spcm
  • mapdl: rfrq,rdsp,mode,cms,dsub

Inputs

pin 0optional
time_scopingname
(scoping | vector | int32)expected type(s)

Time/frequency set IDs required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

if 1, cyclic symmetry is ignored. If 2, cyclic expansion is done (default is 1).

pin 25optional
region_scopingname
(scoping | int32 | vector)expected type(s)

region id (integer) or vector of region ids (vector) or region scoping (scoping) of the model (region corresponds to zone for Fluid results or part for LSDyna results).

Outputs

pin 0requested
meshesname
(meshes_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: meshes_provider
  • full name: mesh.meshes_provider
  • internal name: meshes_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.meshes_provider() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.region_scoping.Connect(my_region_scoping)
my_meshes = op.outputs.meshes.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.meshes_provider() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.region_scoping.connect(my_region_scoping)
my_meshes = op.outputs.meshes()
#include "dpf_api.h"

ansys::dpf::Operator op("meshes_provider"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(14, my_read_cyclic);
op.connect(25, my_region_scoping);
ansys::dpf::MeshesContainer my_meshes = op.getOutput<ansys::dpf::MeshesContainer>(0);

metadata: mesh selection manager provider

Description

Reads mesh properties from the results files contained in the streams or data sources, and makes those properties available through a mesh selection manager in output.

Supported file types

  • mapdl: rst,dsub,rth,rdsp,rfrq

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

streams (result file container) (optional)

pin 4requested
data_sourcesname
(data_sources)expected type(s)

If the stream is null, retrieves the file path from the data sources.

Outputs

pin 0requested
mesh_selection_managername
(mesh_selection_manager)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: mesh_selection_manager_provider
  • full name: metadata.mesh_selection_manager_provider
  • internal name: MeshSelectionManagerProvider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.mesh_selection_manager_provider() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_mesh_selection_manager = op.outputs.mesh_selection_manager.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.mesh_selection_manager_provider() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_mesh_selection_manager = op.outputs.mesh_selection_manager()
#include "dpf_api.h"

ansys::dpf::Operator op("MeshSelectionManagerProvider"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::MeshSelectionManager my_mesh_selection_manager = op.getOutput<ansys::dpf::MeshSelectionManager>(0);

utility: for each

Description

Allows to write a loop over a chunk of operators.

Inputs

pin 0requested
iterablename

Either the result of the make_iterable_info operator, or the operator that must be incremented.

pin 1optional
iterable_valuesname
pin 2optional
pin_indexname
(int32)expected type(s)
pin 3, 4...requested, ellipsis
forwardname

Outputs

pin 0requested
emptyname
pin 3, 4...requested, ellipsis
outputname

Configurations

evaluate_inputs_before_runIf this option is set to true, all input pins of the operator will be evaluated before entering the run method to maintain a correct Operator status.
(bool)expected type(s)
falsedefault value
: If this option is set to true, all input pins of the operator will be evaluated before entering the run method to maintain a correct Operator status.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: for_each
  • full name: utility.for_each
  • internal name: for_each
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.for_each() # operator instantiation
op.inputs.iterable.Connect(my_iterable)
op.inputs.iterable_values.Connect(my_iterable_values)
op.inputs.pin_index.Connect(my_pin_index)
op.inputs.forward1.Connect(my_forward_1)
op.inputs.forward2.Connect(my_forward_2)
my_empty = op.outputs.empty.GetData()
my_output = op.outputs.output.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.for_each() # operator instantiation
op.inputs.iterable.connect(my_iterable)
op.inputs.iterable_values.connect(my_iterable_values)
op.inputs.pin_index.connect(my_pin_index)
op.inputs.forward1.connect(my_forward_1)
op.inputs.forward2.connect(my_forward_2)
my_empty = op.outputs.empty()
my_output = op.outputs.output()
#include "dpf_api.h"

ansys::dpf::Operator op("for_each"); // operator instantiation
op.connect(0, my_iterable);
op.connect(1, my_iterable_values);
op.connect(2, my_pin_index);
op.connect(3, my_forward_1);
op.connect(4, my_forward_2);
ansys::dpf::Any my_empty = op.getOutput<ansys::dpf::Any>(0);
ansys::dpf::Any my_output = op.getOutput<ansys::dpf::Any>(3);

metadata: boundary condition provider

Description

Reads boundary conditions from the results files contained in the streams or data sources.

Supported file types

  • mapdl: rth,mode,rst,cms,rfrq

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
results_infoname
(field | fields_container)expected type(s)

results info

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: boundary_condition_provider
  • full name: metadata.boundary_condition_provider
  • internal name: boundary_conditions
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.boundary_condition_provider() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_results_info = op.outputs.results_info.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.boundary_condition_provider() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_results_info = op.outputs.results_info()
#include "dpf_api.h"

ansys::dpf::Operator op("boundary_conditions"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::Field my_results_info = op.getOutput<ansys::dpf::Field>(0);

utility: custom type field get attribute

Description

A CustomTypeField in pin 0 and a property name (string) in pin 1 are expected in input.

Inputs

pin 0requested
custom_type_fieldname
(custom_type_field)expected type(s)
pin 1requested
property_namename
(string)expected type(s)

Accepted inputs are: 'time_freq_support', 'scoping' and 'header'.

Outputs

pin 0requested
propertyname
(time_freq_support | scoping | abstract_data_tree)expected type(s)

Property value.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: customtypefield_get_attribute
  • full name: utility.customtypefield_get_attribute
  • internal name: customtypefield::get_attribute
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.customtypefield_get_attribute() # operator instantiation
op.inputs.custom_type_field.Connect(my_custom_type_field)
op.inputs.property_name.Connect(my_property_name)
my_property = op.outputs.property.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.customtypefield_get_attribute() # operator instantiation
op.inputs.custom_type_field.connect(my_custom_type_field)
op.inputs.property_name.connect(my_property_name)
my_property = op.outputs.property()
#include "dpf_api.h"

ansys::dpf::Operator op("customtypefield::get_attribute"); // operator instantiation
op.connect(0, my_custom_type_field);
op.connect(1, my_property_name);
ansys::dpf::TimeFreqSupport my_property = op.getOutput<ansys::dpf::TimeFreqSupport>(0);

utility: merge property fields

Description

Assembles a set of property fields into a unique one.

Inputs

pin -201requested
naive_mergename
(bool)expected type(s)

If true, merge the input property fields assuming that there is no repetition in their scoping ids. Default is false.

pin 0, 1...requested, ellipsis
property_fieldsname
(vector> | property_field | property_fields_container)expected type(s)

Either a property fields container, a vector of property fields to merge or property fields from pin 0 to ...

Outputs

pin 0requested
property_fieldname
(property_field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_property_fields
  • full name: utility.merge_property_fields
  • internal name: merge::property_field
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_property_fields() # operator instantiation
op.inputs.naive_merge.Connect(my_naive_merge)
op.inputs.property_fields1.Connect(my_property_fields_1)
op.inputs.property_fields2.Connect(my_property_fields_2)
my_property_field = op.outputs.property_field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_property_fields() # operator instantiation
op.inputs.naive_merge.connect(my_naive_merge)
op.inputs.property_fields1.connect(my_property_fields_1)
op.inputs.property_fields2.connect(my_property_fields_2)
my_property_field = op.outputs.property_field()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::property_field"); // operator instantiation
op.connect(-201, my_naive_merge);
op.connect(0, my_property_fields_1);
op.connect(1, my_property_fields_2);
ansys::dpf::PropertyField my_property_field = op.getOutput<ansys::dpf::PropertyField>(0);

metadata: cyclic analysis?

Description

Reads if the model is cyclic from the result file.

Supported file types

  • hdf5: h5dpf
  • mapdl: rst,rth,rfrq,rdsp

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

streams (result file container) (optional)

pin 4requested
data_sourcesname
(data_sources)expected type(s)

If the stream is null, retrieves the file path from the data sources.

Outputs

pin 0requested
file_pathname
(string)expected type(s)

returns 'single_stage' or 'multi_stage' or an empty string for non cyclic model

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: is_cyclic
  • full name: metadata.is_cyclic
  • internal name: is_cyclic
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.is_cyclic() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_file_path = op.outputs.file_path.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.is_cyclic() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_file_path = op.outputs.file_path()
#include "dpf_api.h"

ansys::dpf::Operator op("is_cyclic"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
std::string my_file_path = op.getOutput<std::string>(0);

metadata: material support provider

Description

Reads the material support.

Supported file types

  • mapdl: rst

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

Streams result file container (optional).

pin 4requested
data_sourcesname
(data_sources)expected type(s)

if the stream is null, get the file path from the data sources.

Outputs

pin 0requested
abstract_field_supportname
(abstract_field_support)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: material_support_provider
  • full name: metadata.material_support_provider
  • internal name: mat_support_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.material_support_provider() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_abstract_field_support = op.outputs.abstract_field_support.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.material_support_provider() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_abstract_field_support = op.outputs.abstract_field_support()
#include "dpf_api.h"

ansys::dpf::Operator op("mat_support_provider"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::AbstractFieldSupport my_abstract_field_support = op.getOutput<ansys::dpf::AbstractFieldSupport>(0);

scoping: reduce sampling scoping

Description

Take a scoping and remove half of it's content.

Inputs

pin 0requested
mesh_scopingname
(scoping)expected type(s)
pin 1optional
denominatorname
(int32)expected type(s)

Set the number of time the scoping is reduced (default is 2). Must be integer value above 1.

Outputs

pin 0requested
mesh_scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: reduce_sampling
  • full name: scoping.reduce_sampling
  • internal name: scoping::reduce_sampling
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.reduce_sampling() # operator instantiation
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.denominator.Connect(my_denominator)
my_mesh_scoping = op.outputs.mesh_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.reduce_sampling() # operator instantiation
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.denominator.connect(my_denominator)
my_mesh_scoping = op.outputs.mesh_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("scoping::reduce_sampling"); // operator instantiation
op.connect(0, my_mesh_scoping);
op.connect(1, my_denominator);
ansys::dpf::Scoping my_mesh_scoping = op.getOutput<ansys::dpf::Scoping>(0);

scoping: on named selection

Description

provides a scoping at a given location based on a given named selection

Inputs

pin 0requested
requested_locationname
(string)expected type(s)
pin 1requested
named_selection_namename
(string)expected type(s)

the string is expected to be in upper case

pin 2optional
int_inclusivename
(int32)expected type(s)

If element scoping is requested on a nodal named selection, if Inclusive == 1 then add all the elements adjacent to the nodes.If Inclusive == 0, only the elements which have all their nodes in the named selection are included

pin 3optional
streams_containername
(streams_container)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
mesh_scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: on_named_selection
  • full name: scoping.on_named_selection
  • internal name: scoping_provider_by_ns
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.on_named_selection() # operator instantiation
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.named_selection_name.Connect(my_named_selection_name)
op.inputs.int_inclusive.Connect(my_int_inclusive)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_mesh_scoping = op.outputs.mesh_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.on_named_selection() # operator instantiation
op.inputs.requested_location.connect(my_requested_location)
op.inputs.named_selection_name.connect(my_named_selection_name)
op.inputs.int_inclusive.connect(my_int_inclusive)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_mesh_scoping = op.outputs.mesh_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("scoping_provider_by_ns"); // operator instantiation
op.connect(0, my_requested_location);
op.connect(1, my_named_selection_name);
op.connect(2, my_int_inclusive);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::Scoping my_mesh_scoping = op.getOutput<ansys::dpf::Scoping>(0);

math: accumulation per scoping

Description

This operator calculates the sum and the percentage of total sum of the input fields container for each scoping of the scopings container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
mesh_scopingname
(scoping)expected type(s)

Master scoping. All scopings in the Scopings Container will be intersected with this scoping.

pin 4requested
data_sourcesname
(data_sources)expected type(s)
pin 5requested
scopings_containername
(scopings_container)expected type(s)

The intersection between the of the first will be used.

Outputs

pin 0requested
accumulation_per_scopingname
(fields_container)expected type(s)
pin 1requested
accumulation_per_scoping_percentagename
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: accumulation_per_scoping
  • full name: math.accumulation_per_scoping
  • internal name: accumulation_per_scoping
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.accumulation_per_scoping() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.scopings_container.Connect(my_scopings_container)
my_accumulation_per_scoping = op.outputs.accumulation_per_scoping.GetData()
my_accumulation_per_scoping_percentage = op.outputs.accumulation_per_scoping_percentage.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.accumulation_per_scoping() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.scopings_container.connect(my_scopings_container)
my_accumulation_per_scoping = op.outputs.accumulation_per_scoping()
my_accumulation_per_scoping_percentage = op.outputs.accumulation_per_scoping_percentage()
#include "dpf_api.h"

ansys::dpf::Operator op("accumulation_per_scoping"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh_scoping);
op.connect(4, my_data_sources);
op.connect(5, my_scopings_container);
ansys::dpf::FieldsContainer my_accumulation_per_scoping = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_accumulation_per_scoping_percentage = op.getOutput<ansys::dpf::FieldsContainer>(1);

metadata: real constants provider

Description

Reads real constants from the result files contained in the streams or data sources.

Supported file types

  • mapdl: rst,rth

Inputs

pin 1optional
solver_real_constants_idsname
(int32 | vector)expected type(s)

Real Constant ids to recover used by the solver. If not set, all available real constants to be recovered.

pin 3optional
streamsname
(streams_container)expected type(s)

Result file container allowed to be kept open to cache data.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Result file path container, used if no streams are set.

Outputs

pin 0, 1...requested, ellipsis
real_constantsname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: real_constants_provider
  • full name: metadata.real_constants_provider
  • internal name: real_constants_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.real_constants_provider() # operator instantiation
op.inputs.solver_real_constants_ids.Connect(my_solver_real_constants_ids)
op.inputs.streams.Connect(my_streams)
op.inputs.data_sources.Connect(my_data_sources)
my_real_constants = op.outputs.real_constants.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.real_constants_provider() # operator instantiation
op.inputs.solver_real_constants_ids.connect(my_solver_real_constants_ids)
op.inputs.streams.connect(my_streams)
op.inputs.data_sources.connect(my_data_sources)
my_real_constants = op.outputs.real_constants()
#include "dpf_api.h"

ansys::dpf::Operator op("real_constants_provider"); // operator instantiation
op.connect(1, my_solver_real_constants_ids);
op.connect(3, my_streams);
op.connect(4, my_data_sources);
ansys::dpf::Field my_real_constants = op.getOutput<ansys::dpf::Field>(0);

metadata: coordinate system data provider

Description

Reads coordinate systems data from the result files contained in the streams or data sources.

Supported file types

  • mapdl: rth,rst

Inputs

pin 1optional
solver_coordinate_system_idsname
(int32 | vector)expected type(s)

Coorfinate System ids to recover used by the solver. If not set, all available materials to be recovered.

pin 3optional
streamsname
(streams_container)expected type(s)

Result file container allowed to be kept open to cache data.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Result file path container, used if no streams are set.

Outputs

pin 0, 1...requested, ellipsis
coordinate_system_dataname
(generic_data_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: coordinate_system_data_provider
  • full name: metadata.coordinate_system_data_provider
  • internal name: coordinate_systems_data_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.coordinate_system_data_provider() # operator instantiation
op.inputs.solver_coordinate_system_ids.Connect(my_solver_coordinate_system_ids)
op.inputs.streams.Connect(my_streams)
op.inputs.data_sources.Connect(my_data_sources)
my_coordinate_system_data = op.outputs.coordinate_system_data.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.coordinate_system_data_provider() # operator instantiation
op.inputs.solver_coordinate_system_ids.connect(my_solver_coordinate_system_ids)
op.inputs.streams.connect(my_streams)
op.inputs.data_sources.connect(my_data_sources)
my_coordinate_system_data = op.outputs.coordinate_system_data()
#include "dpf_api.h"

ansys::dpf::Operator op("coordinate_systems_data_provider"); // operator instantiation
op.connect(1, my_solver_coordinate_system_ids);
op.connect(3, my_streams);
op.connect(4, my_data_sources);
ansys::dpf::GenericDataContainer my_coordinate_system_data = op.getOutput<ansys::dpf::GenericDataContainer>(0);

logic: splitter::streams

Description

Splits a Streams into multiple coherent streams, actual number of outputs is always less or equal to the given desired number of ouputs.

Inputs

pin 0requested
streamsname
(streams_container)expected type(s)

Streams to split.

pin 1requested
output_countname
(int32)expected type(s)

Number of desired outputs.

Outputs

pin -1requested
output_countname
(int32)expected type(s)

Actual number of outputs.

pin 0, 1...requested, ellipsis
outputsname
(streams_container)expected type(s)

Streams outputs.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: split_streams
  • full name: logic.split_streams
  • internal name: splitter::streams
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.split_streams() # operator instantiation
op.inputs.streams.Connect(my_streams)
op.inputs.output_count.Connect(my_output_count)
my_output_count = op.outputs.output_count.GetData()
my_outputs = op.outputs.outputs.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.split_streams() # operator instantiation
op.inputs.streams.connect(my_streams)
op.inputs.output_count.connect(my_output_count)
my_output_count = op.outputs.output_count()
my_outputs = op.outputs.outputs()
#include "dpf_api.h"

ansys::dpf::Operator op("splitter::streams"); // operator instantiation
op.connect(0, my_streams);
op.connect(1, my_output_count);
int my_output_count = op.getOutput<int>(-1);
ansys::dpf::Streams my_outputs = op.getOutput<ansys::dpf::Streams>(0);

result: coordinate system

Description

Extracts the Rotation Matrix and Origin of a specific coordinate system.

Supported file types

  • mapdl: rst

Inputs

pin 0requested
cs_idname
(int32)expected type(s)
pin 3optional
streams_containername
(streams_container)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

the first 9 double are the rotation (3x3 matrix) and the last 3 is the translation vector

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: coordinate_system
  • full name: result.coordinate_system
  • internal name: CS
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.coordinate_system() # operator instantiation
op.inputs.cs_id.Connect(my_cs_id)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.coordinate_system() # operator instantiation
op.inputs.cs_id.connect(my_cs_id)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("CS"); // operator instantiation
op.connect(0, my_cs_id);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

serialization: hdf5dpf custom read

Description

Extract a custom result from an hdf5dpf file. This operator is deprecated, please use the 'custom' operator instead.

Inputs

pin 0optional
time_scopingname
(scoping)expected type(s)
pin 1optional
mesh_scopingname
(scoping)expected type(s)
pin 3optional
streamsname
(streams_container)expected type(s)

Hdf5df file stream.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

Hdf5df file data source.

pin 24optional
meta_dataname
(abstract_data_tree)expected type(s)

meta_data that may be used to evaluate results or extract workflows.

pin 60requested
result_namename

Name of the result that must be extracted from the hdf5dpf file

Outputs

pin 0requested
field_or_fields_containername
(fields_container | field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: hdf5dpf_custom_read
  • full name: serialization.hdf5dpf_custom_read
  • internal name: hdf5::h5dpf::custom
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.hdf5dpf_custom_read() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams.Connect(my_streams)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.meta_data.Connect(my_meta_data)
op.inputs.result_name.Connect(my_result_name)
my_field_or_fields_container = op.outputs.field_or_fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.hdf5dpf_custom_read() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams.connect(my_streams)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.meta_data.connect(my_meta_data)
op.inputs.result_name.connect(my_result_name)
my_field_or_fields_container = op.outputs.field_or_fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("hdf5::h5dpf::custom"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams);
op.connect(4, my_data_sources);
op.connect(24, my_meta_data);
op.connect(60, my_result_name);
ansys::dpf::FieldsContainer my_field_or_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

scoping: rescope custom type field

Description

Rescopes a custom type field on the given scoping. If an ID does not exist in the original custom type field, the default value (in 2) is used when defined.

Inputs

pin 0requested
fieldsname
(custom_type_fields_container | custom_type_field)expected type(s)
pin 1optional
mesh_scopingname
(scoping | vector)expected type(s)
pin 2optional
default_valuename
(custom_type_field | custom_type_field)expected type(s)

If pin 2 is used, the IDs not found in the custom type field are added with this default value.

Outputs

pin 0requested
fieldsname
(custom_type_fields_container | custom_type_field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: rescope_custom_type_field
  • full name: scoping.rescope_custom_type_field
  • internal name: Rescope_ctf
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.rescope_custom_type_field() # operator instantiation
op.inputs.fields.Connect(my_fields)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.default_value.Connect(my_default_value)
my_fields = op.outputs.fields.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.rescope_custom_type_field() # operator instantiation
op.inputs.fields.connect(my_fields)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.default_value.connect(my_default_value)
my_fields = op.outputs.fields()
#include "dpf_api.h"

ansys::dpf::Operator op("Rescope_ctf"); // operator instantiation
op.connect(0, my_fields);
op.connect(1, my_mesh_scoping);
op.connect(2, my_default_value);
ansys::dpf::CustomTypeFieldsContainer my_fields = op.getOutput<ansys::dpf::CustomTypeFieldsContainer>(0);

result: nodal_to_global

Description

Rotates nodal elemental results to global coordinate system

Inputs

pin 0requested
fieldAname
(field)expected type(s)

Vector or tensor field that must be rotated, expressed in nodal coordinate system.

pin 1requested
fieldBname
(field)expected type(s)

Nodal euler angles defined from a result file. Those must be the rotations from Nodal to Global.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Rotated field

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: nodal_to_global
  • full name: result.nodal_to_global
  • internal name: NodalElementalResultsRotation
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.nodal_to_global() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.nodal_to_global() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("NodalElementalResultsRotation"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: global_to_nodal

Description

Rotate results from global coordinate system to local coordinate system.

Inputs

pin 0requested
fieldAname
(field)expected type(s)

Vector or tensor field that must be rotated, expressed in global coordinate system.

pin 1requested
fieldBname
(field)expected type(s)

Nodal euler angles defined from a result file. Those must be the rotations from Nodal to Global.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Rotated field

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: mapdl.global_to_nodal
  • full name: result.mapdl.global_to_nodal
  • internal name: GlobalToNodal
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mapdl.global_to_nodal() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mapdl.global_to_nodal() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("GlobalToNodal"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

min_max: min max by entity over time

Description

Evaluates minimum, maximum over time/frequency and returns those min max as well as the time/freq where they occurred

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 3optional
compute_absolute_valuename
(bool)expected type(s)

Calculate the absolute value of field entities before computing the min/max.

pin 4optional
compute_amplitudename
(bool)expected type(s)

Do calculate amplitude.

Outputs

pin 0requested
minname
(fields_container)expected type(s)
pin 1requested
maxname
(fields_container)expected type(s)
pin 2requested
time_freq_of_minname
(fields_container)expected type(s)
pin 3requested
time_freq_of_maxname
(fields_container)expected type(s)

Configurations

incrementalThis operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
(bool)expected type(s)
truedefault value
: This operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: min_max_over_time_by_entity
  • full name: min_max.min_max_over_time_by_entity
  • internal name: min_max_over_time_by_entity
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.min_max_over_time_by_entity() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.compute_absolute_value.Connect(my_compute_absolute_value)
op.inputs.compute_amplitude.Connect(my_compute_amplitude)
my_min = op.outputs.min.GetData()
my_max = op.outputs.max.GetData()
my_time_freq_of_min = op.outputs.time_freq_of_min.GetData()
my_time_freq_of_max = op.outputs.time_freq_of_max.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.min_max_over_time_by_entity() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.compute_absolute_value.connect(my_compute_absolute_value)
op.inputs.compute_amplitude.connect(my_compute_amplitude)
my_min = op.outputs.min()
my_max = op.outputs.max()
my_time_freq_of_min = op.outputs.time_freq_of_min()
my_time_freq_of_max = op.outputs.time_freq_of_max()
#include "dpf_api.h"

ansys::dpf::Operator op("min_max_over_time_by_entity"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(3, my_compute_absolute_value);
op.connect(4, my_compute_amplitude);
ansys::dpf::FieldsContainer my_min = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_max = op.getOutput<ansys::dpf::FieldsContainer>(1);
ansys::dpf::FieldsContainer my_time_freq_of_min = op.getOutput<ansys::dpf::FieldsContainer>(2);
ansys::dpf::FieldsContainer my_time_freq_of_max = op.getOutput<ansys::dpf::FieldsContainer>(3);

scoping: connectivity ids

Description

Returns the ordered node ids corresponding to the element ids scoping in input. For each element the node ids are its connectivity.

Inputs

pin 1requested
mesh_scopingname
(scoping)expected type(s)

Elemental scoping

pin 7optional
meshname
(abstract_meshed_region)expected type(s)

the support of the scoping is expected if there is no mesh in input

pin 10optional
take_mid_nodesname
(bool)expected type(s)

default is true

Outputs

pin 0requested
mesh_scopingname
(scoping)expected type(s)
pin 1requested
elemental_scopingname
(scoping)expected type(s)

same as the input scoping but with ids duplicated to have the same size as nodal output scoping

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: connectivity_ids
  • full name: scoping.connectivity_ids
  • internal name: scoping::connectivity_ids
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.connectivity_ids() # operator instantiation
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.mesh.Connect(my_mesh)
op.inputs.take_mid_nodes.Connect(my_take_mid_nodes)
my_mesh_scoping = op.outputs.mesh_scoping.GetData()
my_elemental_scoping = op.outputs.elemental_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.connectivity_ids() # operator instantiation
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.mesh.connect(my_mesh)
op.inputs.take_mid_nodes.connect(my_take_mid_nodes)
my_mesh_scoping = op.outputs.mesh_scoping()
my_elemental_scoping = op.outputs.elemental_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("scoping::connectivity_ids"); // operator instantiation
op.connect(1, my_mesh_scoping);
op.connect(7, my_mesh);
op.connect(10, my_take_mid_nodes);
ansys::dpf::Scoping my_mesh_scoping = op.getOutput<ansys::dpf::Scoping>(0);
ansys::dpf::Scoping my_elemental_scoping = op.getOutput<ansys::dpf::Scoping>(1);

min_max: max over time

Description

Evaluates maximum over time/frequency.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 3optional
abs_valuename
(bool)expected type(s)

Should use absolute value.

pin 4optional
compute_amplitudename
(bool)expected type(s)

Do calculate amplitude.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

incrementalThis operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
(bool)expected type(s)
truedefault value
: This operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: max_over_time_by_entity
  • full name: min_max.max_over_time_by_entity
  • internal name: max_over_time_by_entity
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.max_over_time_by_entity() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.abs_value.Connect(my_abs_value)
op.inputs.compute_amplitude.Connect(my_compute_amplitude)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.max_over_time_by_entity() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.abs_value.connect(my_abs_value)
op.inputs.compute_amplitude.connect(my_compute_amplitude)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("max_over_time_by_entity"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(3, my_abs_value);
op.connect(4, my_compute_amplitude);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: split in for each range

Description

Split a scoping into several pieces so you can iterate it with a for_each loop.

Inputs

pin 0optional
iterablename

Iterable that can be combined with the one currently generated.

pin 1requested
operator_to_iteratename
(operator)expected type(s)

Operator that must be reconnected with the range values.

pin 2requested
pin_indexname
(int32)expected type(s)
pin 3requested
scopingname
(scoping)expected type(s)
pin 4requested
chunk_sizename
(int32)expected type(s)

Outputs

pin 0requested
outputname

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: split_in_for_each_range
  • full name: utility.split_in_for_each_range
  • internal name: chunk_in_for_each_range
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.split_in_for_each_range() # operator instantiation
op.inputs.iterable.Connect(my_iterable)
op.inputs.operator_to_iterate.Connect(my_operator_to_iterate)
op.inputs.pin_index.Connect(my_pin_index)
op.inputs.scoping.Connect(my_scoping)
op.inputs.chunk_size.Connect(my_chunk_size)
my_output = op.outputs.output.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.split_in_for_each_range() # operator instantiation
op.inputs.iterable.connect(my_iterable)
op.inputs.operator_to_iterate.connect(my_operator_to_iterate)
op.inputs.pin_index.connect(my_pin_index)
op.inputs.scoping.connect(my_scoping)
op.inputs.chunk_size.connect(my_chunk_size)
my_output = op.outputs.output()
#include "dpf_api.h"

ansys::dpf::Operator op("chunk_in_for_each_range"); // operator instantiation
op.connect(0, my_iterable);
op.connect(1, my_operator_to_iterate);
op.connect(2, my_pin_index);
op.connect(3, my_scoping);
op.connect(4, my_chunk_size);
ansys::dpf::Any my_output = op.getOutput<ansys::dpf::Any>(0);

metadata: cyclic support provider

Description

Read the cyclic support (DPF entity containing necessary information for expansions) and expands the mesh.

Supported file types

  • hdf5: h5dpf
  • mapdl: rth,rst

Inputs

pin 3optional
streams_containername
(streams_container)expected type(s)

Streams containing the result file.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

data sources containing the result file.

pin 7optional
sector_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh of the first sector.

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

if this pin is set, expanding the mesh is not necessary.

pin 18optional
sectors_to_expandname
(scoping | scopings_container | vector)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label.

Outputs

pin 0requested
cyclic_supportname
(cyclic_support)expected type(s)
pin 1requested
sector_meshesname
(meshes_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: cyclic_support_provider
  • full name: metadata.cyclic_support_provider
  • internal name: support_provider_cyclic
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.cyclic_support_provider() # operator instantiation
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.sector_meshed_region.Connect(my_sector_meshed_region)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
my_cyclic_support = op.outputs.cyclic_support.GetData()
my_sector_meshes = op.outputs.sector_meshes.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.cyclic_support_provider() # operator instantiation
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.sector_meshed_region.connect(my_sector_meshed_region)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
my_cyclic_support = op.outputs.cyclic_support()
my_sector_meshes = op.outputs.sector_meshes()
#include "dpf_api.h"

ansys::dpf::Operator op("support_provider_cyclic"); // operator instantiation
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_sector_meshed_region);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
ansys::dpf::CyclicSupport my_cyclic_support = op.getOutput<ansys::dpf::CyclicSupport>(0);
ansys::dpf::MeshesContainer my_sector_meshes = op.getOutput<ansys::dpf::MeshesContainer>(1);

mesh: skin

Description

Extracts a skin of the mesh in a new meshed region. The material ID of initial elements are propagated to their facets.

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)
pin 1optional
mesh_scopingname
(scoping)expected type(s)

Nodal scoping to restrict the skin extraction to a set of nodes. If provided, a skin element is added to the skin mesh if all its nodes are in the scoping.

pin 2optional
duplicate_shellname
(bool)expected type(s)

If input mesh contains shell elements, output mesh shell elements (boolean = 1) are duplicated, one per each orientation, or (boolean = 0) remain unchanged.

pin 3optional
add_beam_pointname
(bool)expected type(s)

If input mesh contains beam or point elements, output mesh beam point elements (boolean = 1) are added or (boolean = 0) are ignored. Default: False

Outputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)

Skin meshed region with facets and facets_to_ele property fields.

pin 1requested
nodes_mesh_scopingname
(scoping)expected type(s)
pin 2requested
map_new_elements_to_oldname
(umap)expected type(s)
pin 3requested
property_field_new_elements_to_oldname
(property_field)expected type(s)

This property field provides, for each new face element ID (in the scoping), the corresponding 3D volume element index (in the data) it has been extracted from. The 3D volume element ID can be found with the element scoping of the input mesh.

pin 4requested
facet_indicesname
(property_field)expected type(s)

This property field gives, for each new face element ID (in the scoping), the corresponding face index on the source 3D volume element. The 3D volume element can be extracted from the previous output.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: skin
  • full name: mesh.skin
  • internal name: meshed_skin_sector
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.skin() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.duplicate_shell.Connect(my_duplicate_shell)
op.inputs.add_beam_point.Connect(my_add_beam_point)
my_mesh = op.outputs.mesh.GetData()
my_nodes_mesh_scoping = op.outputs.nodes_mesh_scoping.GetData()
my_map_new_elements_to_old = op.outputs.map_new_elements_to_old.GetData()
my_property_field_new_elements_to_old = op.outputs.property_field_new_elements_to_old.GetData()
my_facet_indices = op.outputs.facet_indices.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.skin() # operator instantiation
op.inputs.mesh.connect(my_mesh)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.duplicate_shell.connect(my_duplicate_shell)
op.inputs.add_beam_point.connect(my_add_beam_point)
my_mesh = op.outputs.mesh()
my_nodes_mesh_scoping = op.outputs.nodes_mesh_scoping()
my_map_new_elements_to_old = op.outputs.map_new_elements_to_old()
my_property_field_new_elements_to_old = op.outputs.property_field_new_elements_to_old()
my_facet_indices = op.outputs.facet_indices()
#include "dpf_api.h"

ansys::dpf::Operator op("meshed_skin_sector"); // operator instantiation
op.connect(0, my_mesh);
op.connect(1, my_mesh_scoping);
op.connect(2, my_duplicate_shell);
op.connect(3, my_add_beam_point);
ansys::dpf::MeshedRegion my_mesh = op.getOutput<ansys::dpf::MeshedRegion>(0);
ansys::dpf::Scoping my_nodes_mesh_scoping = op.getOutput<ansys::dpf::Scoping>(1);
ansys::dpf::Umap my_map_new_elements_to_old = op.getOutput<ansys::dpf::Umap>(2);
ansys::dpf::PropertyField my_property_field_new_elements_to_old = op.getOutput<ansys::dpf::PropertyField>(3);
ansys::dpf::PropertyField my_facet_indices = op.getOutput<ansys::dpf::PropertyField>(4);

utility: change shell layers

Description

Extract the requested shell layers from the input fields. If the fields contain only one layer and the permissive configuration input is set to true then it returns the input fields. If permissive configuration input is set to false, any change which should not be permitted won't be achieved and the corresponding field in the output will be empty. If permissive configuration input is set to true (default), carefully check the result.

Inputs

pin 0requested
fields_containername
(fields_container | field)expected type(s)
pin 1requested
e_shell_layername
(int32 | enum dataProcessing::EShellLayers)expected type(s)

0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

pin 2optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

Mesh support of the input fields_container, in case it does not have one defined. If the fields_container contains mixed shell/solid results, the mesh is required (either by connecting this pin or in the support).

pin 26optional
mergename
(bool)expected type(s)

For fields with mixed shell layers (solid/shell elements with heterogeneous shell layers), group all of them in the same field (false by default).

Outputs

pin 0requested
fields_containername
(fields_container | field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
permissiveIf permissive is set to false, the operator run will ensure the 'change shell layers' operation is allowed (for example, if asking mid layer for a field defined on top and bottom layers, the computed field will be empty). If permissive is set to true, the operator run will be done in a permissive way (no check). Default is true.
(bool)expected type(s)
truedefault value
: If permissive is set to false, the operator run will ensure the 'change shell layers' operation is allowed (for example, if asking mid layer for a field defined on top and bottom layers, the computed field will be empty). If permissive is set to true, the operator run will be done in a permissive way (no check). Default is true.

Scripting

  • category: utility
  • plugin: core
  • scripting name: change_shell_layers
  • full name: utility.change_shell_layers
  • internal name: change_shellLayers
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.change_shell_layers() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.e_shell_layer.Connect(my_e_shell_layer)
op.inputs.mesh.Connect(my_mesh)
op.inputs.merge.Connect(my_merge)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.change_shell_layers() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.e_shell_layer.connect(my_e_shell_layer)
op.inputs.mesh.connect(my_mesh)
op.inputs.merge.connect(my_merge)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("change_shellLayers"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_e_shell_layer);
op.connect(2, my_mesh);
op.connect(26, my_merge);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: merge meshes

Description

Take a set of meshes and assemble them in a unique one

Inputs

pin -201optional
naive_merge_elementsname
(bool)expected type(s)

If true, merge the elemental Property Fields of the input meshes assuming that there is no repetition in their scoping ids. Default is false.

pin -200optional
should_merge_named_selectionsname
(bool)expected type(s)

For certain types of files (such as RST), scoping from names selection does not need to be merged.If this pin is true, the merge occurs. If this pin is false, the merge does not occur. Default is true.

pin 0, 1...requested, ellipsis
meshesname
(vector> | abstract_meshed_region | meshes_container)expected type(s)

A vector of meshed region to merge or meshed region from pin 0 to ...

pin 101optional
merge_methodname
(int32)expected type(s)

0: merge by distance, 1: merge by node id (default)

pin 102optional
box_sizename
(double)expected type(s)

Box size used when merging by distance. Default value is 1e-12.

pin 103optional
remove_duplicate_elementsname
(int32)expected type(s)

0: keep duplicate elements (default), 1: remove duplicate elements

Outputs

pin 0requested
merges_meshname
(abstract_meshed_region)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
read_inputs_in_parallelIf this option is set to true, the operator's inputs will be evaluated in parallel.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the operator's inputs will be evaluated in parallel.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_meshes
  • full name: utility.merge_meshes
  • internal name: merge::mesh
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_meshes() # operator instantiation
op.inputs.naive_merge_elements.Connect(my_naive_merge_elements)
op.inputs.should_merge_named_selections.Connect(my_should_merge_named_selections)
op.inputs.meshes1.Connect(my_meshes_1)
op.inputs.meshes2.Connect(my_meshes_2)
op.inputs.merge_method.Connect(my_merge_method)
op.inputs.box_size.Connect(my_box_size)
op.inputs.remove_duplicate_elements.Connect(my_remove_duplicate_elements)
my_merges_mesh = op.outputs.merges_mesh.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_meshes() # operator instantiation
op.inputs.naive_merge_elements.connect(my_naive_merge_elements)
op.inputs.should_merge_named_selections.connect(my_should_merge_named_selections)
op.inputs.meshes1.connect(my_meshes_1)
op.inputs.meshes2.connect(my_meshes_2)
op.inputs.merge_method.connect(my_merge_method)
op.inputs.box_size.connect(my_box_size)
op.inputs.remove_duplicate_elements.connect(my_remove_duplicate_elements)
my_merges_mesh = op.outputs.merges_mesh()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::mesh"); // operator instantiation
op.connect(-201, my_naive_merge_elements);
op.connect(-200, my_should_merge_named_selections);
op.connect(0, my_meshes_1);
op.connect(1, my_meshes_2);
op.connect(101, my_merge_method);
op.connect(102, my_box_size);
op.connect(103, my_remove_duplicate_elements);
ansys::dpf::MeshedRegion my_merges_mesh = op.getOutput<ansys::dpf::MeshedRegion>(0);

result: add rigid body motion (fields container)

Description

Adds a given rigid translation, center and rotation from a displacement field. The rotation is given in terms of rotations angles. Note that the displacement field has to be in the global coordinate system

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
translation_fieldname
(field)expected type(s)
pin 2requested
rotation_fieldname
(field)expected type(s)
pin 3requested
center_fieldname
(field)expected type(s)
pin 7optional
meshname
(abstract_meshed_region)expected type(s)

default is the mesh in the support

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: add_rigid_body_motion_fc
  • full name: result.add_rigid_body_motion_fc
  • internal name: RigidBodyAddition_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.add_rigid_body_motion_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.translation_field.Connect(my_translation_field)
op.inputs.rotation_field.Connect(my_rotation_field)
op.inputs.center_field.Connect(my_center_field)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.add_rigid_body_motion_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.translation_field.connect(my_translation_field)
op.inputs.rotation_field.connect(my_rotation_field)
op.inputs.center_field.connect(my_center_field)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("RigidBodyAddition_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_translation_field);
op.connect(2, my_rotation_field);
op.connect(3, my_center_field);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: members in linear compression bending not certified

Description

This operator is a non-certified example of buckling resistance verification for the compression and bending members for Class I, 2 and 3 cross-sections. It is only provided as an example if you want to develop your own compute norm operator. This norm is linear summation of the utilization ratios of compression members and bending members. The results computed by this beta operator have not been certified by ANSYS. ANSYS declines all responsibility for the use of this operator.

Inputs

pin 0optional
time_scopingname
(scoping | vector | int32)expected type(s)
pin 1requested
field_yield_strengthname
(field)expected type(s)

This pin contains field of beam's Yield Strength defined by the user.

pin 2optional
field_end_conditionname
(data_sources | field)expected type(s)

This pin contains file csv or field of beam's end condition defined by the user. If no input at this pin found, it would take end conditions value of all beams as 1

pin 3optional
streamsname
(streams_container)expected type(s)

result file container allowed to be kept open to cache data.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set.

pin 5optional
manufacturename
(bool)expected type(s)

Manufacturing processus:hot finished if TRUE or cold formed if FALSE. Default value : hot finished.

pin 6optional
partial_factorname
(double)expected type(s)

partial factor for resistance of members to instability assessed by member checks. Default value: 1.0

pin 7requested
meshname
(abstract_meshed_region)expected type(s)

Mesh containing beam's properties defined by user

pin 8requested
bending_moment_yname
(fields_container)expected type(s)

Fields Container of bending moment on axis y defined by user

pin 9requested
bending_moment_zname
(fields_container)expected type(s)

Fields Container of bending moment on axis z defined by user

pin 10requested
axial_forcename
(fields_container)expected type(s)

Fields Container of axial force defined by user

pin 11requested
class_cross_sectionname
(bool)expected type(s)

Selection for a cross-section. True: Class 1 or 2 cross-sections. False: Class 3 cross section. If the user defines the cross section as class 1 or 2, the section modulus would be plastic section modulus. If it's class 3- cross section,the section modulus would be elastic section modulus

pin 12optional
fabrication_typename
(bool)expected type(s)

Selection of fabrication's type if there are beams I in the structure. TRUE: Rolled Section, False: Welded Section. Default: Rolled Section.

Outputs

pin 0requested
buckling_resistance_linear_summation_utilization_ratiosname
(fields_container)expected type(s)

Linear summation of the utilization ratios in all members submitted under a combination of both bending and compression. These factors should be less than 1 and positive.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: members_in_linear_compression_bending_not_certified
  • full name: result.members_in_linear_compression_bending_not_certified
  • internal name: members_in_linear_compression_bending_not_certified
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.members_in_linear_compression_bending_not_certified() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.field_yield_strength.Connect(my_field_yield_strength)
op.inputs.field_end_condition.Connect(my_field_end_condition)
op.inputs.streams.Connect(my_streams)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.manufacture.Connect(my_manufacture)
op.inputs.partial_factor.Connect(my_partial_factor)
op.inputs.mesh.Connect(my_mesh)
op.inputs.bending_moment_y.Connect(my_bending_moment_y)
op.inputs.bending_moment_z.Connect(my_bending_moment_z)
op.inputs.axial_force.Connect(my_axial_force)
op.inputs.class_cross_section.Connect(my_class_cross_section)
op.inputs.fabrication_type.Connect(my_fabrication_type)
my_buckling_resistance_linear_summation_utilization_ratios = op.outputs.buckling_resistance_linear_summation_utilization_ratios.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.members_in_linear_compression_bending_not_certified() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.field_yield_strength.connect(my_field_yield_strength)
op.inputs.field_end_condition.connect(my_field_end_condition)
op.inputs.streams.connect(my_streams)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.manufacture.connect(my_manufacture)
op.inputs.partial_factor.connect(my_partial_factor)
op.inputs.mesh.connect(my_mesh)
op.inputs.bending_moment_y.connect(my_bending_moment_y)
op.inputs.bending_moment_z.connect(my_bending_moment_z)
op.inputs.axial_force.connect(my_axial_force)
op.inputs.class_cross_section.connect(my_class_cross_section)
op.inputs.fabrication_type.connect(my_fabrication_type)
my_buckling_resistance_linear_summation_utilization_ratios = op.outputs.buckling_resistance_linear_summation_utilization_ratios()
#include "dpf_api.h"

ansys::dpf::Operator op("members_in_linear_compression_bending_not_certified"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_field_yield_strength);
op.connect(2, my_field_end_condition);
op.connect(3, my_streams);
op.connect(4, my_data_sources);
op.connect(5, my_manufacture);
op.connect(6, my_partial_factor);
op.connect(7, my_mesh);
op.connect(8, my_bending_moment_y);
op.connect(9, my_bending_moment_z);
op.connect(10, my_axial_force);
op.connect(11, my_class_cross_section);
op.connect(12, my_fabrication_type);
ansys::dpf::FieldsContainer my_buckling_resistance_linear_summation_utilization_ratios = op.getOutput<ansys::dpf::FieldsContainer>(0);

invariant: convertnum nod to bcs

Description

Converts a fields container from NOD to BCS ordering.

Inputs

pin 2requested
fields_containername
(fields_container)expected type(s)

fields_container

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Data_sources (must contain the full file).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: invariant
  • plugin: mapdl
  • scripting name: convertnum_nod_to_bcs
  • full name: invariant.convertnum_nod_to_bcs
  • internal name: convertnum_nod_to_bcs
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.convertnum_nod_to_bcs() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.data_sources.Connect(my_data_sources)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.convertnum_nod_to_bcs() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.data_sources.connect(my_data_sources)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("convertnum_nod_to_bcs"); // operator instantiation
op.connect(2, my_fields_container);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

geo: gauss to node (field)

Description

Extrapolating results available at Gauss or quadrature points to nodal points for one field. The available elements are: Linear quadrangle, parabolic quadrangle, linear hexagonal, quadratic hexagonal, linear tetrahedral, and quadratic tetrahedral

Inputs

pin 0requested
fieldname
(field)expected type(s)
pin 1optional
scopingname
(scoping)expected type(s)

Scoping to integrate on, if not provided, the one from input field is provided.

pin 7optional
meshname
(abstract_meshed_region)expected type(s)

Mesh to integrate on.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: geo
  • plugin: core
  • scripting name: gauss_to_node
  • full name: geo.gauss_to_node
  • internal name: gauss_to_node
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.gauss_to_node() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.scoping.Connect(my_scoping)
op.inputs.mesh.Connect(my_mesh)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.gauss_to_node() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.scoping.connect(my_scoping)
op.inputs.mesh.connect(my_mesh)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("gauss_to_node"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_scoping);
op.connect(7, my_mesh);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

filter: band pass (timefreq)

Description

The band pass filter returns all the values above (but not equal to) the minimum threshold value and below (but not equal to) the maximum threshold value in input.

Inputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1requested
min_thresholdname
(double | field)expected type(s)

A minimum threshold scalar or a field containing one value is expected.

pin 2optional
max_thresholdname
(double | field)expected type(s)

A maximum threshold scalar or a field containing one value is expected.

Outputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: timefreq_band_pass
  • full name: filter.timefreq_band_pass
  • internal name: core::timefreq::band_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.timefreq_band_pass() # operator instantiation
op.inputs.time_freq_support.Connect(my_time_freq_support)
op.inputs.min_threshold.Connect(my_min_threshold)
op.inputs.max_threshold.Connect(my_max_threshold)
my_time_freq_support = op.outputs.time_freq_support.GetData()
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.timefreq_band_pass() # operator instantiation
op.inputs.time_freq_support.connect(my_time_freq_support)
op.inputs.min_threshold.connect(my_min_threshold)
op.inputs.max_threshold.connect(my_max_threshold)
my_time_freq_support = op.outputs.time_freq_support()
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("core::timefreq::band_pass"); // operator instantiation
op.connect(0, my_time_freq_support);
op.connect(1, my_min_threshold);
op.connect(2, my_max_threshold);
ansys::dpf::TimeFreqSupport my_time_freq_support = op.getOutput<ansys::dpf::TimeFreqSupport>(0);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(1);

serialization: deserializer

Description

Takes a file generated by the serializer and deserializes it into DPF's entities.

Inputs

pin -1requested
stream_typename
(int32)expected type(s)

0 for ASCII (default), and 1 for binary

pin 0requested
file_pathname
(string)expected type(s)

file path

Outputs

pin 1, 2...requested, ellipsis
any_outputname
(any)expected type(s)

number and types of outputs corresponding of the inputs used in the serialization

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: deserializer
  • full name: serialization.deserializer
  • internal name: deserializer
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.deserializer() # operator instantiation
op.inputs.stream_type.Connect(my_stream_type)
op.inputs.file_path.Connect(my_file_path)
my_any_output = op.outputs.any_output.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.deserializer() # operator instantiation
op.inputs.stream_type.connect(my_stream_type)
op.inputs.file_path.connect(my_file_path)
my_any_output = op.outputs.any_output()
#include "dpf_api.h"

ansys::dpf::Operator op("deserializer"); // operator instantiation
op.connect(-1, my_stream_type);
op.connect(0, my_file_path);
ansys::dpf::Any my_any_output = op.getOutput<ansys::dpf::Any>(1);

utility: remote workflow instantiate

Description

Sends a local workflow to a remote process (and keep a local image of it) or create a local image of an existing remote workflow (identified by an id and an address) for a given protocol registered in the streams.

Inputs

pin 0requested
workflow_to_sendname
(workflow | int32)expected type(s)

local workflow to push to a remote or id of a remote workflow

pin 3requested
streams_to_remotename
(streams_container)expected type(s)
pin 4optional
data_sources_to_remotename
(data_sources)expected type(s)

Outputs

pin 0requested
remote_workflowname
(workflow)expected type(s)

remote workflow containing an image of the remote workflow and the protocols streams

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: utility
  • plugin: core
  • scripting name: remote_workflow_instantiate
  • full name: utility.remote_workflow_instantiate
  • internal name: remote_workflow_instantiate
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.remote_workflow_instantiate() # operator instantiation
op.inputs.workflow_to_send.Connect(my_workflow_to_send)
op.inputs.streams_to_remote.Connect(my_streams_to_remote)
op.inputs.data_sources_to_remote.Connect(my_data_sources_to_remote)
my_remote_workflow = op.outputs.remote_workflow.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.remote_workflow_instantiate() # operator instantiation
op.inputs.workflow_to_send.connect(my_workflow_to_send)
op.inputs.streams_to_remote.connect(my_streams_to_remote)
op.inputs.data_sources_to_remote.connect(my_data_sources_to_remote)
my_remote_workflow = op.outputs.remote_workflow()
#include "dpf_api.h"

ansys::dpf::Operator op("remote_workflow_instantiate"); // operator instantiation
op.connect(0, my_workflow_to_send);
op.connect(3, my_streams_to_remote);
op.connect(4, my_data_sources_to_remote);
ansys::dpf::Workflow my_remote_workflow = op.getOutput<ansys::dpf::Workflow>(0);

utility: remote operator instantiate

Description

Create a local image of an existing remote operator (identified by an id and an address) for a given protocol registered in the streams. A workflow is created with this operator and returned in output

Inputs

pin 0requested
operator_to_sendname
(int32)expected type(s)

local workflow to push to a remote or id of a remote workflow

pin 1requested
output_pinname
(int32)expected type(s)

pin number of the output to name

pin 3requested
streams_to_remotename
(streams_container)expected type(s)
pin 4optional
data_sources_to_remotename
(data_sources)expected type(s)
pin 5requested
output_namename
(string)expected type(s)

output's name of the workflow to return

Outputs

pin 0requested
remote_workflowname
(workflow)expected type(s)

remote workflow containing an image of the remote workflow and the protocols streams

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: utility
  • plugin: core
  • scripting name: remote_operator_instantiate
  • full name: utility.remote_operator_instantiate
  • internal name: remote_operator_instantiate
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.remote_operator_instantiate() # operator instantiation
op.inputs.operator_to_send.Connect(my_operator_to_send)
op.inputs.output_pin.Connect(my_output_pin)
op.inputs.streams_to_remote.Connect(my_streams_to_remote)
op.inputs.data_sources_to_remote.Connect(my_data_sources_to_remote)
op.inputs.output_name.Connect(my_output_name)
my_remote_workflow = op.outputs.remote_workflow.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.remote_operator_instantiate() # operator instantiation
op.inputs.operator_to_send.connect(my_operator_to_send)
op.inputs.output_pin.connect(my_output_pin)
op.inputs.streams_to_remote.connect(my_streams_to_remote)
op.inputs.data_sources_to_remote.connect(my_data_sources_to_remote)
op.inputs.output_name.connect(my_output_name)
my_remote_workflow = op.outputs.remote_workflow()
#include "dpf_api.h"

ansys::dpf::Operator op("remote_operator_instantiate"); // operator instantiation
op.connect(0, my_operator_to_send);
op.connect(1, my_output_pin);
op.connect(3, my_streams_to_remote);
op.connect(4, my_data_sources_to_remote);
op.connect(5, my_output_name);
ansys::dpf::Workflow my_remote_workflow = op.getOutput<ansys::dpf::Workflow>(0);

utility: clone field to shell layer

Description

Generates a Field from the Field in input 0 that has the same FieldDefinition with the exception of the shellLayers enum that is specified in input 1. The DataPointer is recomputed to the appropriate value. The Data of the output Field is 0.0 for all entities. Scoping can be shared or not based on the optional pin 2.

Inputs

pin 0requested
fieldname
(field)expected type(s)
pin 1requested
shell_layername
(int32 | enum dataProcessing::EShellLayers)expected type(s)

0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid.

pin 2optional
duplicate_scopingname
(bool)expected type(s)

If true, a new scoping is computed for the output Field. If false, the input Field scoping is used. Default is false.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: field_clone_to_shell_layer
  • full name: utility.field_clone_to_shell_layer
  • internal name: field::clone_to_shell_layer
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.field_clone_to_shell_layer() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.shell_layer.Connect(my_shell_layer)
op.inputs.duplicate_scoping.Connect(my_duplicate_scoping)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.field_clone_to_shell_layer() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.shell_layer.connect(my_shell_layer)
op.inputs.duplicate_scoping.connect(my_duplicate_scoping)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("field::clone_to_shell_layer"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_shell_layer);
op.connect(2, my_duplicate_scoping);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: compute residual and error

Description

Computes the Lp-norm of a field or a field container. When a second entry is provided, the residual (the difference between the first and second entry) is calculated along with the error as the Lp-norm of the difference. When a second input is not provided, the calculation is only completed for the first entry. The type of calculation performed is based on the specifications provided for pin 1, pin 2 defines the type of error norm (L1 vs L2), and pin 3 which entity to use as a reference

Inputs

pin 0requested
field_or_fields_container1name
(field | fields_container)expected type(s)

field or fields container - compulsory

pin 1optional
normalization_typename
(int32)expected type(s)

type of normalization applied to the residuals and norm calculation (optional, defaut: absolute): 0 for absolute, 1 for relative to the first entry at a given time step, 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

pin 2optional
norm_calculation_typename
(int32)expected type(s)

type for norm calculation (optional, default: L2) - It is normalized depending on Pin2 selection 1 for L1, ie sum(abs(xi)), 2 for L2, ie sqrt(sum((xi^2))

pin 3optional
field_referencename
(int32)expected type(s)

Field reference for the normalization step, default: 0 for entry 1, 1 for residuals - optional

pin 4optional
field_or_fields_container2name
(field | fields_container)expected type(s)

field or fields container of same dimensionality as entry 1 - optional

Outputs

pin 0requested
residualsname
(field | fields_container)expected type(s)

0: normalized residuals (aka field 1 - field 2) as a field or field container, normalized depending on the normalization type

pin 1requested
errorname
(field | fields_container)expected type(s)

1: error as a field or a field container depending on the entry's type.

pin 2requested
residuals_normalization_factorname
(field | fields_container)expected type(s)

2: factor used for residual normalization

pin 3requested
error_normalization_factorname
(field | fields_container)expected type(s)

3: factor used for error norm normalization

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
truedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.

Scripting

  • category: math
  • plugin: core
  • scripting name: compute_residual_and_error
  • full name: math.compute_residual_and_error
  • internal name: error_norm_calc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.compute_residual_and_error() # operator instantiation
op.inputs.field_or_fields_container1.Connect(my_field_or_fields_container1)
op.inputs.normalization_type.Connect(my_normalization_type)
op.inputs.norm_calculation_type.Connect(my_norm_calculation_type)
op.inputs.field_reference.Connect(my_field_reference)
op.inputs.field_or_fields_container2.Connect(my_field_or_fields_container2)
my_residuals = op.outputs.residuals.GetData()
my_error = op.outputs.error.GetData()
my_residuals_normalization_factor = op.outputs.residuals_normalization_factor.GetData()
my_error_normalization_factor = op.outputs.error_normalization_factor.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.compute_residual_and_error() # operator instantiation
op.inputs.field_or_fields_container1.connect(my_field_or_fields_container1)
op.inputs.normalization_type.connect(my_normalization_type)
op.inputs.norm_calculation_type.connect(my_norm_calculation_type)
op.inputs.field_reference.connect(my_field_reference)
op.inputs.field_or_fields_container2.connect(my_field_or_fields_container2)
my_residuals = op.outputs.residuals()
my_error = op.outputs.error()
my_residuals_normalization_factor = op.outputs.residuals_normalization_factor()
my_error_normalization_factor = op.outputs.error_normalization_factor()
#include "dpf_api.h"

ansys::dpf::Operator op("error_norm_calc"); // operator instantiation
op.connect(0, my_field_or_fields_container1);
op.connect(1, my_normalization_type);
op.connect(2, my_norm_calculation_type);
op.connect(3, my_field_reference);
op.connect(4, my_field_or_fields_container2);
ansys::dpf::Field my_residuals = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_error = op.getOutput<ansys::dpf::Field>(1);
ansys::dpf::Field my_residuals_normalization_factor = op.getOutput<ansys::dpf::Field>(2);
ansys::dpf::Field my_error_normalization_factor = op.getOutput<ansys::dpf::Field>(3);

min_max: incremental over fields container

Description

Compute the component-wise minimum (out 0) and maximum (out 1) over a fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
field_minname
(field)expected type(s)
pin 1requested
field_maxname
(field)expected type(s)

Configurations

incrementalThis operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
(bool)expected type(s)
truedefault value
: This operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: min_max_fc_inc
  • full name: min_max.min_max_fc_inc
  • internal name: min_max_fc_inc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.min_max_fc_inc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_field_min = op.outputs.field_min.GetData()
my_field_max = op.outputs.field_max.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.min_max_fc_inc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_field_min = op.outputs.field_min()
my_field_max = op.outputs.field_max()
#include "dpf_api.h"

ansys::dpf::Operator op("min_max_fc_inc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::Field my_field_min = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_field_max = op.getOutput<ansys::dpf::Field>(1);

scoping: split on property type

Description

Splits a given scoping or the mesh scoping (nodal or elemental) on given properties (elshape and/or material, since 2025R1 it supports any scalar property field name contained in the mesh property fields) and returns a scopings container with those split scopings.

Inputs

pin 1optional
mesh_scopingname
(scoping)expected type(s)

Scoping

pin 7requested
meshname
(abstract_meshed_region)expected type(s)

mesh region

pin 9requested
requested_locationname
(string)expected type(s)

location (default is elemental)

pin 12optional
skin_casename
(int32)expected type(s)

set to 0: to have skin elements in their own group, 1: merge skin and solid elements, 2: merge skin and shell elements (default)

pin 13, 14...optional, ellipsis
labelname
(string | vector)expected type(s)

properties to apply the filtering 'mat' and/or 'elshape' (since 2025R1 it supports any property name contained in the mesh property fields) (default is 'elshape')

Outputs

pin 0requested
mesh_scopingname
(scopings_container)expected type(s)

Scoping

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: split_on_property_type
  • full name: scoping.split_on_property_type
  • internal name: scoping::by_property
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.split_on_property_type() # operator instantiation
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.skin_case.Connect(my_skin_case)
op.inputs.label1.Connect(my_label_1)
op.inputs.label2.Connect(my_label_2)
my_mesh_scoping = op.outputs.mesh_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.split_on_property_type() # operator instantiation
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.skin_case.connect(my_skin_case)
op.inputs.label1.connect(my_label_1)
op.inputs.label2.connect(my_label_2)
my_mesh_scoping = op.outputs.mesh_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("scoping::by_property"); // operator instantiation
op.connect(1, my_mesh_scoping);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(12, my_skin_case);
op.connect(13, my_label_1);
op.connect(14, my_label_2);
ansys::dpf::ScopingsContainer my_mesh_scoping = op.getOutput<ansys::dpf::ScopingsContainer>(0);

utility: overlap fields

Description

Take two fields and superpose them, the overlapping field will override values of base_field.

Inputs

pin 0optional
base_fieldname
(field)expected type(s)
pin 1optional
overlapping_fieldname
(field)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: overlap_fields
  • full name: utility.overlap_fields
  • internal name: overlap_fields
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.overlap_fields() # operator instantiation
op.inputs.base_field.Connect(my_base_field)
op.inputs.overlapping_field.Connect(my_overlapping_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.overlap_fields() # operator instantiation
op.inputs.base_field.connect(my_base_field)
op.inputs.overlapping_field.connect(my_overlapping_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("overlap_fields"); // operator instantiation
op.connect(0, my_base_field);
op.connect(1, my_overlapping_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

mapping: find reduced coordinates

Description

Finds the elements corresponding to the given coordinates in input and computes their reduced coordinates in those elements.

Inputs

pin 1requested
coordinatesname
(field | fields_container | abstract_meshed_region | meshes_container)expected type(s)
pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

If the first field in input has no mesh in support, then the mesh in this pin is expected (default is false). If a meshes container with several meshes is set, it should be on the same label spaces as the coordinates fields container.

pin 200optional
use_quadratic_elementsname
(bool)expected type(s)

If this pin is set to true, reduced coordinates are computed on the quadratic element if the element is quadratic (more precise but less performant). Default is false.

Outputs

pin 0requested
reduced_coordinatesname
(fields_container)expected type(s)

coordinates in the reference elements

pin 1requested
element_idsname
(scopings_container)expected type(s)

Ids of the elements where each set of reduced coordinates is found

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mapping
  • plugin: core
  • scripting name: find_reduced_coordinates
  • full name: mapping.find_reduced_coordinates
  • internal name: find_reduced_coordinates
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mapping.find_reduced_coordinates() # operator instantiation
op.inputs.coordinates.Connect(my_coordinates)
op.inputs.mesh.Connect(my_mesh)
op.inputs.use_quadratic_elements.Connect(my_use_quadratic_elements)
my_reduced_coordinates = op.outputs.reduced_coordinates.GetData()
my_element_ids = op.outputs.element_ids.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mapping.find_reduced_coordinates() # operator instantiation
op.inputs.coordinates.connect(my_coordinates)
op.inputs.mesh.connect(my_mesh)
op.inputs.use_quadratic_elements.connect(my_use_quadratic_elements)
my_reduced_coordinates = op.outputs.reduced_coordinates()
my_element_ids = op.outputs.element_ids()
#include "dpf_api.h"

ansys::dpf::Operator op("find_reduced_coordinates"); // operator instantiation
op.connect(1, my_coordinates);
op.connect(7, my_mesh);
op.connect(200, my_use_quadratic_elements);
ansys::dpf::FieldsContainer my_reduced_coordinates = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::ScopingsContainer my_element_ids = op.getOutput<ansys::dpf::ScopingsContainer>(1);

scoping: rescope property field

Description

Rescopes a property field on the given scoping. If an ID does not exist in the original property field, the default value (in 2) is used when defined.

Inputs

pin 0requested
fieldsname
(property_fields_container | property_field)expected type(s)
pin 1optional
mesh_scopingname
(scoping | vector)expected type(s)
pin 2optional
default_valuename
(int32 | vector)expected type(s)

If pin 2 is used, the IDs not found in the property field are added with this default value.

Outputs

pin 0requested
fieldsname
(property_fields_container | property_field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: rescope_property_field
  • full name: scoping.rescope_property_field
  • internal name: Rescope_pf
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.rescope_property_field() # operator instantiation
op.inputs.fields.Connect(my_fields)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.default_value.Connect(my_default_value)
my_fields = op.outputs.fields.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.rescope_property_field() # operator instantiation
op.inputs.fields.connect(my_fields)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.default_value.connect(my_default_value)
my_fields = op.outputs.fields()
#include "dpf_api.h"

ansys::dpf::Operator op("Rescope_pf"); // operator instantiation
op.connect(0, my_fields);
op.connect(1, my_mesh_scoping);
op.connect(2, my_default_value);
ansys::dpf::PropertyFieldsContainer my_fields = op.getOutput<ansys::dpf::PropertyFieldsContainer>(0);

averaging: elemental nodal to nodal elemental (field)

Description

Transforms an Elemental Nodal field to Nodal Elemental. The result is computed on a given node's scoping.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
mesh_scopingname
(scoping)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: elemental_nodal_to_nodal_elemental
  • full name: averaging.elemental_nodal_to_nodal_elemental
  • internal name: ElementalNodal_To_NodalElemental
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.elemental_nodal_to_nodal_elemental() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.elemental_nodal_to_nodal_elemental() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("ElementalNodal_To_NodalElemental"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_mesh_scoping);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

scoping: adapt with scopings container

Description

Rescopes/splits a fields container to correspond to a scopings container.

Inputs

pin 0requested
field_or_fields_containername
(fields_container | field)expected type(s)
pin 1requested
scopings_containername
(scopings_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: adapt_with_scopings_container
  • full name: scoping.adapt_with_scopings_container
  • internal name: rescope_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.adapt_with_scopings_container() # operator instantiation
op.inputs.field_or_fields_container.Connect(my_field_or_fields_container)
op.inputs.scopings_container.Connect(my_scopings_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.adapt_with_scopings_container() # operator instantiation
op.inputs.field_or_fields_container.connect(my_field_or_fields_container)
op.inputs.scopings_container.connect(my_scopings_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("rescope_fc"); // operator instantiation
op.connect(0, my_field_or_fields_container);
op.connect(1, my_scopings_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

scoping: nodes in mesh

Description

Retrieves the nodal scoping of a given input mesh, which contains the node IDs.

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
mesh_scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: nodal_from_mesh
  • full name: scoping.nodal_from_mesh
  • internal name: GetNodeScopingFromMesh
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.nodal_from_mesh() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
my_mesh_scoping = op.outputs.mesh_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.nodal_from_mesh() # operator instantiation
op.inputs.mesh.connect(my_mesh)
my_mesh_scoping = op.outputs.mesh_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("GetNodeScopingFromMesh"); // operator instantiation
op.connect(0, my_mesh);
ansys::dpf::Scoping my_mesh_scoping = op.getOutput<ansys::dpf::Scoping>(0);

utility: merge any objects

Description

Merges a list of objects having the same data types. Once the data type is found, the merge operation is forwarded to the correct merge Operator.

Inputs

pin 0, 1...requested, ellipsis
anyname
(any)expected type(s)

Either a vector of objects (sharing the same data types) or objects from pin 0 to ... to merge. Supported types rely on existing type specific merge operators.

Outputs

pin 0requested
anyname
(any)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
read_inputs_in_parallelIf this option is set to true, the operator's inputs will be evaluated in parallel.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the operator's inputs will be evaluated in parallel.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_any
  • full name: utility.merge_any
  • internal name: merge::any
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_any() # operator instantiation
op.inputs.any1.Connect(my_any_1)
op.inputs.any2.Connect(my_any_2)
my_any = op.outputs.any.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_any() # operator instantiation
op.inputs.any1.connect(my_any_1)
op.inputs.any2.connect(my_any_2)
my_any = op.outputs.any()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::any"); // operator instantiation
op.connect(0, my_any_1);
op.connect(1, my_any_2);
ansys::dpf::Any my_any = op.getOutput<ansys::dpf::Any>(0);

utility: merge time freq supports

Description

Assembles a set of time/frequency supports into a unique one.

Inputs

pin 0, 1...requested, ellipsis
time_freq_supportsname
(vector> | time_freq_support)expected type(s)

A vector of time/frequency supports to merge or time/frequency supports from pin 0 to ...

Outputs

pin 0requested
merged_supportname
(time_freq_support)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_time_freq_supports
  • full name: utility.merge_time_freq_supports
  • internal name: merge::time_freq_support
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_time_freq_supports() # operator instantiation
op.inputs.time_freq_supports1.Connect(my_time_freq_supports_1)
op.inputs.time_freq_supports2.Connect(my_time_freq_supports_2)
my_merged_support = op.outputs.merged_support.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_time_freq_supports() # operator instantiation
op.inputs.time_freq_supports1.connect(my_time_freq_supports_1)
op.inputs.time_freq_supports2.connect(my_time_freq_supports_2)
my_merged_support = op.outputs.merged_support()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::time_freq_support"); // operator instantiation
op.connect(0, my_time_freq_supports_1);
op.connect(1, my_time_freq_supports_2);
ansys::dpf::TimeFreqSupport my_merged_support = op.getOutput<ansys::dpf::TimeFreqSupport>(0);

utility: merge scopings

Description

Assembles a set of scopings into a unique one.

Inputs

pin 0, 1...requested, ellipsis
scopingsname
(scoping | scopings_container | vector>)expected type(s)

Either a scopings container, a vector of scopings to merge, or scopings from pin 0 to ...

Outputs

pin 0requested
merged_scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_scopings
  • full name: utility.merge_scopings
  • internal name: merge::scoping
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_scopings() # operator instantiation
op.inputs.scopings1.Connect(my_scopings_1)
op.inputs.scopings2.Connect(my_scopings_2)
my_merged_scoping = op.outputs.merged_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_scopings() # operator instantiation
op.inputs.scopings1.connect(my_scopings_1)
op.inputs.scopings2.connect(my_scopings_2)
my_merged_scoping = op.outputs.merged_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::scoping"); // operator instantiation
op.connect(0, my_scopings_1);
op.connect(1, my_scopings_2);
ansys::dpf::Scoping my_merged_scoping = op.getOutput<ansys::dpf::Scoping>(0);

utility: merge weighted fields

Description

Assembles a set of fields into a unique one, applying a weight on the sum of the fields.

Inputs

pin -2optional
sum_mergename
(bool)expected type(s)

Default is false. If true, redundant quantities are summed instead of being ignored.

pin -1optional
merged_supportname
(abstract_field_support)expected type(s)

Already merged field support.

pin 0, 1...requested, ellipsis
fieldsname
(vector> | field | fields_container)expected type(s)

Either a fields container, a vector of fields to merge, or fields from pin 0 to ...

pin 1000, 1001...requested, ellipsis
weightsname
(vector> | property_field)expected type(s)

Weights to apply to each field from pin 1000 to ...

Outputs

pin 0requested
merged_fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_weighted_fields
  • full name: utility.merge_weighted_fields
  • internal name: merge::weighted_field
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_weighted_fields() # operator instantiation
op.inputs.sum_merge.Connect(my_sum_merge)
op.inputs.merged_support.Connect(my_merged_support)
op.inputs.fields1.Connect(my_fields_1)
op.inputs.fields2.Connect(my_fields_2)
op.inputs.weights1.Connect(my_weights_1)
op.inputs.weights2.Connect(my_weights_2)
my_merged_field = op.outputs.merged_field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_weighted_fields() # operator instantiation
op.inputs.sum_merge.connect(my_sum_merge)
op.inputs.merged_support.connect(my_merged_support)
op.inputs.fields1.connect(my_fields_1)
op.inputs.fields2.connect(my_fields_2)
op.inputs.weights1.connect(my_weights_1)
op.inputs.weights2.connect(my_weights_2)
my_merged_field = op.outputs.merged_field()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::weighted_field"); // operator instantiation
op.connect(-2, my_sum_merge);
op.connect(-1, my_merged_support);
op.connect(0, my_fields_1);
op.connect(1, my_fields_2);
op.connect(1000, my_weights_1);
op.connect(1001, my_weights_2);
ansys::dpf::Field my_merged_field = op.getOutput<ansys::dpf::Field>(0);

utility: merge fields

Description

Assembles a set of fields into a unique one.

Inputs

pin -2optional
sum_mergename
(bool)expected type(s)

Default is false. If true, redundant quantities are summed instead of being ignored.

pin -1optional
merged_supportname
(abstract_field_support)expected type(s)

Already merged field support.

pin 0, 1...requested, ellipsis
fieldsname
(vector> | field | fields_container)expected type(s)

Either a fields container, a vector of fields to merge, or fields from pin 0 to ...

Outputs

pin 0requested
merged_fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
read_inputs_in_parallelIf this option is set to true, the operator's inputs will be evaluated in parallel.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the operator's inputs will be evaluated in parallel.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_fields
  • full name: utility.merge_fields
  • internal name: merge::field
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_fields() # operator instantiation
op.inputs.sum_merge.Connect(my_sum_merge)
op.inputs.merged_support.Connect(my_merged_support)
op.inputs.fields1.Connect(my_fields_1)
op.inputs.fields2.Connect(my_fields_2)
my_merged_field = op.outputs.merged_field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_fields() # operator instantiation
op.inputs.sum_merge.connect(my_sum_merge)
op.inputs.merged_support.connect(my_merged_support)
op.inputs.fields1.connect(my_fields_1)
op.inputs.fields2.connect(my_fields_2)
my_merged_field = op.outputs.merged_field()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::field"); // operator instantiation
op.connect(-2, my_sum_merge);
op.connect(-1, my_merged_support);
op.connect(0, my_fields_1);
op.connect(1, my_fields_2);
ansys::dpf::Field my_merged_field = op.getOutput<ansys::dpf::Field>(0);

filter: high pass (field)

Description

The high pass filter returns all the values above (but not equal to) the threshold value in input.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
thresholdname
(double | field)expected type(s)

A threshold scalar or a field containing one value is expected.

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: field_high_pass
  • full name: filter.field_high_pass
  • internal name: core::field::high_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.field_high_pass() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.field_high_pass() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("core::field::high_pass"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: merge fc to fc field matrices

Description

Merge fields of fields container into field matrices. The output is a fields container of field matrices.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

fields container to be merged

pin 1requested
labelname
(string)expected type(s)

Label where the merge is required

pin 2optional
time_scopingname
(int32 | vector | scoping)expected type(s)

if it's specified, fields container of field matrices is constructed only on the specified time scoping

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

fields container of field matrices obtained after merging.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge::fields_container_matrices_label
  • full name: utility.merge::fields_container_matrices_label
  • internal name: merge::fields_container_matrices_label
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge::fields_container_matrices_label() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.label.Connect(my_label)
op.inputs.time_scoping.Connect(my_time_scoping)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge::fields_container_matrices_label() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.label.connect(my_label)
op.inputs.time_scoping.connect(my_time_scoping)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::fields_container_matrices_label"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_label);
op.connect(2, my_time_scoping);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

min_max: max by component

Description

Give the maximum for each element rank by comparing several fields.

Inputs

pin 0requested
use_absolute_valuename
(bool)expected type(s)

use_absolute_value

pin 1, 2...requested, ellipsis
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: max_by_component
  • full name: min_max.max_by_component
  • internal name: max_by_component
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.max_by_component() # operator instantiation
op.inputs.use_absolute_value.Connect(my_use_absolute_value)
op.inputs.field1.Connect(my_field_1)
op.inputs.field2.Connect(my_field_2)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.max_by_component() # operator instantiation
op.inputs.use_absolute_value.connect(my_use_absolute_value)
op.inputs.field1.connect(my_field_1)
op.inputs.field2.connect(my_field_2)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("max_by_component"); // operator instantiation
op.connect(0, my_use_absolute_value);
op.connect(1, my_field_1);
op.connect(2, my_field_2);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: weighted merge fields by label

Description

Performs a weighted merge on fields of a fields container that share the same label value.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
labelname
(string)expected type(s)

Label identifier that should be merged.

pin 2optional
merged_field_supportname
(abstract_field_support)expected type(s)

The FieldsContainer's support that has already been merged.

pin 3optional
sum_mergename
(bool)expected type(s)

Default is false. If true, redundant quantities are summed instead of being ignored.

pin 1000, 1001...requested, ellipsis
weightsname
(vector>> | property_field)expected type(s)

Weights to apply to each field from pin 1000 to ...

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: weighted_merge_fields_by_label
  • full name: utility.weighted_merge_fields_by_label
  • internal name: merge::weighted_fields_container_label
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.weighted_merge_fields_by_label() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.label.Connect(my_label)
op.inputs.merged_field_support.Connect(my_merged_field_support)
op.inputs.sum_merge.Connect(my_sum_merge)
op.inputs.weights1.Connect(my_weights_1)
op.inputs.weights2.Connect(my_weights_2)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.weighted_merge_fields_by_label() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.label.connect(my_label)
op.inputs.merged_field_support.connect(my_merged_field_support)
op.inputs.sum_merge.connect(my_sum_merge)
op.inputs.weights1.connect(my_weights_1)
op.inputs.weights2.connect(my_weights_2)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::weighted_fields_container_label"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_label);
op.connect(2, my_merged_field_support);
op.connect(3, my_sum_merge);
op.connect(1000, my_weights_1);
op.connect(1001, my_weights_2);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: merge fields by label

Description

Merges the fields of a fields container that share the same label value.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
labelname
(string)expected type(s)

Label identifier that should be merged.

pin 2optional
merged_field_supportname
(abstract_field_support)expected type(s)

The FieldsContainer's support that has already been merged.

pin 3optional
sum_mergename
(bool)expected type(s)

Default is false. If true, redundant quantities are summed instead of being ignored.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
merged_field_supportname
(abstract_field_support)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_fields_by_label
  • full name: utility.merge_fields_by_label
  • internal name: merge::fields_container_label
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_fields_by_label() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.label.Connect(my_label)
op.inputs.merged_field_support.Connect(my_merged_field_support)
op.inputs.sum_merge.Connect(my_sum_merge)
my_fields_container = op.outputs.fields_container.GetData()
my_merged_field_support = op.outputs.merged_field_support.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_fields_by_label() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.label.connect(my_label)
op.inputs.merged_field_support.connect(my_merged_field_support)
op.inputs.sum_merge.connect(my_sum_merge)
my_fields_container = op.outputs.fields_container()
my_merged_field_support = op.outputs.merged_field_support()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::fields_container_label"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_label);
op.connect(2, my_merged_field_support);
op.connect(3, my_sum_merge);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::AbstractFieldSupport my_merged_field_support = op.getOutput<ansys::dpf::AbstractFieldSupport>(1);

compression: kMeans clustering

Description

Apply kMeans clustering to group data depending on the data's non-linearity.

Inputs

pin 0optional
clusters_numbername
(int32)expected type(s)

number of the clusters (dafault is 3)

pin 1optional
formulaname
(string)expected type(s)

formula ('dist'/'dotprod'), default is 'dist'

pin 2requested
fields_containername
(fields_container)expected type(s)

an iunput fields container containing the data which will be used for the clustering

pin 3optional
component_numbername
(int32)expected type(s)

component number as an int (default is 0), ex '0' for X-displacement, '1' for Y-displacement,...

Outputs

pin 0requested
scoping_clustersname
(scopings_container)expected type(s)

Scopings container with the space scoping (entities' ids) corresponding to each of k-clusters

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: compression
  • plugin: core
  • scripting name: kmeans_clustering
  • full name: compression.kmeans_clustering
  • internal name: kmeans_operator
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.compression.kmeans_clustering() # operator instantiation
op.inputs.clusters_number.Connect(my_clusters_number)
op.inputs.formula.Connect(my_formula)
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.component_number.Connect(my_component_number)
my_scoping_clusters = op.outputs.scoping_clusters.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.compression.kmeans_clustering() # operator instantiation
op.inputs.clusters_number.connect(my_clusters_number)
op.inputs.formula.connect(my_formula)
op.inputs.fields_container.connect(my_fields_container)
op.inputs.component_number.connect(my_component_number)
my_scoping_clusters = op.outputs.scoping_clusters()
#include "dpf_api.h"

ansys::dpf::Operator op("kmeans_operator"); // operator instantiation
op.connect(0, my_clusters_number);
op.connect(1, my_formula);
op.connect(2, my_fields_container);
op.connect(3, my_component_number);
ansys::dpf::ScopingsContainer my_scoping_clusters = op.getOutput<ansys::dpf::ScopingsContainer>(0);

utility: merge meshes containers

Description

Assembles a set of meshes containers into a unique one.

Inputs

pin 0, 1...requested, ellipsis
meshes_containersname
(vector> | meshes_container)expected type(s)

a vector of meshes containers to merge or meshes containers from pin 0 to ...

Outputs

pin 0requested
merged_meshes_containername
(meshes_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
read_inputs_in_parallelIf this option is set to true, the operator's inputs will be evaluated in parallel.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the operator's inputs will be evaluated in parallel.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_meshes_containers
  • full name: utility.merge_meshes_containers
  • internal name: merge::meshes_container
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_meshes_containers() # operator instantiation
op.inputs.meshes_containers1.Connect(my_meshes_containers_1)
op.inputs.meshes_containers2.Connect(my_meshes_containers_2)
my_merged_meshes_container = op.outputs.merged_meshes_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_meshes_containers() # operator instantiation
op.inputs.meshes_containers1.connect(my_meshes_containers_1)
op.inputs.meshes_containers2.connect(my_meshes_containers_2)
my_merged_meshes_container = op.outputs.merged_meshes_container()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::meshes_container"); // operator instantiation
op.connect(0, my_meshes_containers_1);
op.connect(1, my_meshes_containers_2);
ansys::dpf::MeshesContainer my_merged_meshes_container = op.getOutput<ansys::dpf::MeshesContainer>(0);

utility: merge data tree

Description

Merges a list of data trees. Attributes names shouldn't be shared accross data tree instances.

Inputs

pin 0, 1...requested, ellipsis
data_treename
(data_tree | vector>)expected type(s)

Either a vector of data trees or data trees from pin 0 to ... to merge.

Outputs

pin 0requested
anyname
(any)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
falsedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_data_tree
  • full name: utility.merge_data_tree
  • internal name: merge::data_tree
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_data_tree() # operator instantiation
op.inputs.data_tree1.Connect(my_data_tree_1)
op.inputs.data_tree2.Connect(my_data_tree_2)
my_any = op.outputs.any.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_data_tree() # operator instantiation
op.inputs.data_tree1.connect(my_data_tree_1)
op.inputs.data_tree2.connect(my_data_tree_2)
my_any = op.outputs.any()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::data_tree"); // operator instantiation
op.connect(0, my_data_tree_1);
op.connect(1, my_data_tree_2);
ansys::dpf::Any my_any = op.getOutput<ansys::dpf::Any>(0);

utility: merge collections

Description

Merges a set of collections into a unique one.

Inputs

pin 0, 1...requested, ellipsis
collectionsname
(vector> | any_collection)expected type(s)

a vector of collections to merge or collections from pin 0 to ...

Outputs

pin 0requested
merged_collectionsname
(any_collection)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
read_inputs_in_parallelIf this option is set to true, the operator's inputs will be evaluated in parallel.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the operator's inputs will be evaluated in parallel.

Scripting

  • category: utility
  • plugin: core
  • scripting name: merge_collections
  • full name: utility.merge_collections
  • internal name: merge::any_collection
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.merge_collections() # operator instantiation
op.inputs.collections1.Connect(my_collections_1)
op.inputs.collections2.Connect(my_collections_2)
my_merged_collections = op.outputs.merged_collections.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.merge_collections() # operator instantiation
op.inputs.collections1.connect(my_collections_1)
op.inputs.collections2.connect(my_collections_2)
my_merged_collections = op.outputs.merged_collections()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::any_collection"); // operator instantiation
op.connect(0, my_collections_1);
op.connect(1, my_collections_2);
ansys::dpf::AnyCollection my_merged_collections = op.getOutput<ansys::dpf::AnyCollection>(0);

min_max: min max by entity

Description

Compute the entity-wise minimum (out 0) and maximum (out 1) through all fields of a fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
field_minname
(field)expected type(s)
pin 1requested
field_maxname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: min_max_by_entity
  • full name: min_max.min_max_by_entity
  • internal name: min_max_by_entity
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.min_max_by_entity() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_field_min = op.outputs.field_min.GetData()
my_field_max = op.outputs.field_max.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.min_max_by_entity() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_field_min = op.outputs.field_min()
my_field_max = op.outputs.field_max()
#include "dpf_api.h"

ansys::dpf::Operator op("min_max_by_entity"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::Field my_field_min = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_field_max = op.getOutput<ansys::dpf::Field>(1);

result: von mises stresses as mechanical

Description

Computes the equivalent (Von Mises) stresses and averages it to the nodes (by default). For multibody simulations, averaging across bodies can either be activated or deactivated.

Inputs

pin 0optional
time_scopingname
(scoping | vector)expected type(s)

time/freq (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.

pin 1optional
mesh_scopingname
(scoping | scopings_container)expected type(s)

nodes or elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the results file.

pin 9optional
requested_locationname
(string)expected type(s)

average the elemental nodal result to the requested location (default is nodal).

pin 14optional
read_cyclicname
(bool)expected type(s)

if true, cyclic expansion is done. If false, it's ignored..

pin 200optional
average_across_bodiesname
(bool)expected type(s)

for multibody simulations, the stresses are averaged across bodies if true or not if false (default).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
meshes_containername
(meshes_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mechanical_results
  • scripting name: stress_eqv_as_mechanical
  • full name: result.stress_eqv_as_mechanical
  • internal name: stress_eqv_as_mechanical
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_eqv_as_mechanical() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.average_across_bodies.Connect(my_average_across_bodies)
my_fields_container = op.outputs.fields_container.GetData()
my_meshes_container = op.outputs.meshes_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_eqv_as_mechanical() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.average_across_bodies.connect(my_average_across_bodies)
my_fields_container = op.outputs.fields_container()
my_meshes_container = op.outputs.meshes_container()
#include "dpf_api.h"

ansys::dpf::Operator op("stress_eqv_as_mechanical"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(200, my_average_across_bodies);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::MeshesContainer my_meshes_container = op.getOutput<ansys::dpf::MeshesContainer>(1);

serialization: workflow to pydpf

Description

Generates a PyDPF script that can recreate the given workflow. The script is returned as a string, and can optionally be saved to a specified path.

Inputs

pin 0requested
workflowname
(workflow)expected type(s)
pin 1optional
output_pathname
(string)expected type(s)

Outputs

pin 0requested
pydpf_codename
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: workflow_to_pydpf
  • full name: serialization.workflow_to_pydpf
  • internal name: workflow_to_pydpf
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.workflow_to_pydpf() # operator instantiation
op.inputs.workflow.Connect(my_workflow)
op.inputs.output_path.Connect(my_output_path)
my_pydpf_code = op.outputs.pydpf_code.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.workflow_to_pydpf() # operator instantiation
op.inputs.workflow.connect(my_workflow)
op.inputs.output_path.connect(my_output_path)
my_pydpf_code = op.outputs.pydpf_code()
#include "dpf_api.h"

ansys::dpf::Operator op("workflow_to_pydpf"); // operator instantiation
op.connect(0, my_workflow);
op.connect(1, my_output_path);
std::string my_pydpf_code = op.getOutput<std::string>(0);

logic: merge solid and shell fields

Description

Merges shell and solid fields for each time step/frequency in the fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: solid_shell_fields
  • full name: logic.solid_shell_fields
  • internal name: merge::solid_shell_fields
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.solid_shell_fields() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.solid_shell_fields() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("merge::solid_shell_fields"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

min_max: min max over time

Description

Evaluates minimum, maximum by time or frequency over all the entities of each field

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 2optional
compute_absolute_valuename
(bool)expected type(s)

Calculate the absolute value of field entities before computing the min/max.

Outputs

pin 0requested
minname
(fields_container)expected type(s)
pin 1requested
maxname
(fields_container)expected type(s)

Configurations

incrementalThis operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
(bool)expected type(s)
truedefault value
: This operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: min_max_by_time
  • full name: min_max.min_max_by_time
  • internal name: min_max_by_time
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.min_max_by_time() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.compute_absolute_value.Connect(my_compute_absolute_value)
my_min = op.outputs.min.GetData()
my_max = op.outputs.max.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.min_max_by_time() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.compute_absolute_value.connect(my_compute_absolute_value)
my_min = op.outputs.min()
my_max = op.outputs.max()
#include "dpf_api.h"

ansys::dpf::Operator op("min_max_by_time"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(2, my_compute_absolute_value);
ansys::dpf::FieldsContainer my_min = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_max = op.getOutput<ansys::dpf::FieldsContainer>(1);

geo: element nodal contribution

Description

Compute the fraction of the element measure attributed to each node of each element (fraction of the volume for 3D elements, fraction of the area for 2D elements or fraction of the length for 1D elements). It is computed by taking the integral of the shape function associated to each node within each element.

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)
pin 1optional
scopingname
(scoping)expected type(s)

Integrate the input field over a specific scoping.

pin 2optional
volume_fractionname
(bool)expected type(s)

If true, returns influence volume, area or length. If false, the values are normalized with the element volume, area or length. Default: true.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: geo
  • plugin: core
  • scripting name: element_nodal_contribution
  • full name: geo.element_nodal_contribution
  • internal name: element::nodal_contribution
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.element_nodal_contribution() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
op.inputs.scoping.Connect(my_scoping)
op.inputs.volume_fraction.Connect(my_volume_fraction)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.element_nodal_contribution() # operator instantiation
op.inputs.mesh.connect(my_mesh)
op.inputs.scoping.connect(my_scoping)
op.inputs.volume_fraction.connect(my_volume_fraction)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("element::nodal_contribution"); // operator instantiation
op.connect(0, my_mesh);
op.connect(1, my_scoping);
op.connect(2, my_volume_fraction);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

min_max: min over time

Description

Evaluates minimum over time/frequency.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 3optional
abs_valuename
(bool)expected type(s)

Should use absolute value.

pin 4optional
compute_amplitudename
(bool)expected type(s)

Do calculate amplitude.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

incrementalThis operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
(bool)expected type(s)
truedefault value
: This operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: min_over_time_by_entity
  • full name: min_max.min_over_time_by_entity
  • internal name: min_over_time_by_entity
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.min_over_time_by_entity() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.abs_value.Connect(my_abs_value)
op.inputs.compute_amplitude.Connect(my_compute_amplitude)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.min_over_time_by_entity() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.abs_value.connect(my_abs_value)
op.inputs.compute_amplitude.connect(my_compute_amplitude)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("min_over_time_by_entity"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(3, my_abs_value);
op.connect(4, my_compute_amplitude);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: transient rayleigh integration

Description

Computes the transient Rayleigh integral

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

the input field container expects acceleration fields

pin 1requested
meshname
(abstract_meshed_region | meshes_container)expected type(s)

The meshes region in this pin has to be boundary or skin mesh. This is the source meshes.

pin 2requested
time_scopingname
(int32 | vector | scoping)expected type(s)

Load step number (if it's specified, the Transient rayleigh integration is computed only on the substeps of this step) or time scoping

pin 3requested
fieldname
(field)expected type(s)

The field represents the coordinates of the observation position. It should be specified if not observation mesh is provided.

pin 4requested
observation_meshname
(abstract_meshed_region)expected type(s)

This is the observation mesh region

pin 5requested
mass_densityname
(double)expected type(s)

Mass density (if it's not specified, default value of the air is applied).

pin 6requested
speed_of_soundname
(double)expected type(s)

Speed of sound (if it's not specified, default value of the speed of sound in the air is applied).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: transient_rayleigh_integration
  • full name: result.transient_rayleigh_integration
  • internal name: transient_rayleigh_integration
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.transient_rayleigh_integration() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.field.Connect(my_field)
op.inputs.observation_mesh.Connect(my_observation_mesh)
op.inputs.mass_density.Connect(my_mass_density)
op.inputs.speed_of_sound.Connect(my_speed_of_sound)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.transient_rayleigh_integration() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.field.connect(my_field)
op.inputs.observation_mesh.connect(my_observation_mesh)
op.inputs.mass_density.connect(my_mass_density)
op.inputs.speed_of_sound.connect(my_speed_of_sound)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("transient_rayleigh_integration"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(2, my_time_scoping);
op.connect(3, my_field);
op.connect(4, my_observation_mesh);
op.connect(5, my_mass_density);
op.connect(6, my_speed_of_sound);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

min_max: over field

Description

Compute the component-wise minimum (out 0) and maximum (out 1) over a field.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
field_minname
(field)expected type(s)
pin 1requested
field_maxname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: min_max
  • full name: min_max.min_max
  • internal name: min_max
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.min_max() # operator instantiation
op.inputs.field.Connect(my_field)
my_field_min = op.outputs.field_min.GetData()
my_field_max = op.outputs.field_max.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.min_max() # operator instantiation
op.inputs.field.connect(my_field)
my_field_min = op.outputs.field_min()
my_field_max = op.outputs.field_max()
#include "dpf_api.h"

ansys::dpf::Operator op("min_max"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field_min = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_field_max = op.getOutput<ansys::dpf::Field>(1);

min_max: over label

Description

Create two fields (0 min 1 max) by looping over the fields container in input and taking the min/max value by component through all the fields having the same id for the label set in input (in pin 1). If no label is specified or if the specified label doesn't exist, the operation is done over all the fields. The fields out are located on the label set in input, so their scoping are the labels ids.For each min max value, the label id for one other fields container labels is kept and returned in a scoping in pin 2 (min) and 3 (max).The field's scoping ids of the value kept in min max are also returned in the scopings in pin 4 (min) and 5 (max).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
labelname
(string)expected type(s)

label name from the fields container

Outputs

pin 0requested
field_minname
(field)expected type(s)
pin 1requested
field_maxname
(field)expected type(s)
pin 2optional
domain_ids_minname
(scoping)expected type(s)
pin 3optional
domain_ids_maxname
(scoping)expected type(s)
pin 4requested
scoping_ids_minname
(scoping)expected type(s)
pin 5requested
scoping_ids_maxname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: min_max_over_label_fc
  • full name: min_max.min_max_over_label_fc
  • internal name: min_max_over_label_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.min_max_over_label_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.label.Connect(my_label)
my_field_min = op.outputs.field_min.GetData()
my_field_max = op.outputs.field_max.GetData()
my_domain_ids_min = op.outputs.domain_ids_min.GetData()
my_domain_ids_max = op.outputs.domain_ids_max.GetData()
my_scoping_ids_min = op.outputs.scoping_ids_min.GetData()
my_scoping_ids_max = op.outputs.scoping_ids_max.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.min_max_over_label_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.label.connect(my_label)
my_field_min = op.outputs.field_min()
my_field_max = op.outputs.field_max()
my_domain_ids_min = op.outputs.domain_ids_min()
my_domain_ids_max = op.outputs.domain_ids_max()
my_scoping_ids_min = op.outputs.scoping_ids_min()
my_scoping_ids_max = op.outputs.scoping_ids_max()
#include "dpf_api.h"

ansys::dpf::Operator op("min_max_over_label_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_label);
ansys::dpf::Field my_field_min = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_field_max = op.getOutput<ansys::dpf::Field>(1);
ansys::dpf::Scoping my_domain_ids_min = op.getOutput<ansys::dpf::Scoping>(2);
ansys::dpf::Scoping my_domain_ids_max = op.getOutput<ansys::dpf::Scoping>(3);
ansys::dpf::Scoping my_scoping_ids_min = op.getOutput<ansys::dpf::Scoping>(4);
ansys::dpf::Scoping my_scoping_ids_max = op.getOutput<ansys::dpf::Scoping>(5);

min_max: min by component

Description

Give the minimum for each element rank by comparing several fields.

Inputs

pin 0requested
use_absolute_valuename
(bool)expected type(s)

use_absolute_value

pin 1, 2...requested, ellipsis
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: min_by_component
  • full name: min_max.min_by_component
  • internal name: min_by_component
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.min_by_component() # operator instantiation
op.inputs.use_absolute_value.Connect(my_use_absolute_value)
op.inputs.field1.Connect(my_field_1)
op.inputs.field2.Connect(my_field_2)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.min_by_component() # operator instantiation
op.inputs.use_absolute_value.connect(my_use_absolute_value)
op.inputs.field1.connect(my_field_1)
op.inputs.field2.connect(my_field_2)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("min_by_component"); // operator instantiation
op.connect(0, my_use_absolute_value);
op.connect(1, my_field_1);
op.connect(2, my_field_2);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: average over label

Description

Compute the component-wise average over all the fields that have the same ID as the label set as input in the fields container. This computation can be incremental. If the input fields container is connected and the operator is run multiple times, the output field will be on all the connected inputs.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
labelname
(string)expected type(s)

Label of the fields container where it should operate.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

incrementalThis operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
(bool)expected type(s)
truedefault value
: This operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: average_over_label_fc
  • full name: math.average_over_label_fc
  • internal name: average_over_label_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.average_over_label_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.label.Connect(my_label)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.average_over_label_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.label.connect(my_label)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("average_over_label_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_label);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: accumulate level over label

Description

Compute the component-wise sum over all the fields that have the same ID as the label set as input in the fields container and apply 10.0xlog10(data/10xx-12) on the result. This computation can be incremental. If the input fields container is connected and the operator is run multiple times, the output field will be on all the connected inputs.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
labelname
(string)expected type(s)

Label of the fields container where it should operate.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

incrementalThis operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
(bool)expected type(s)
truedefault value
: This operator can be run several times with different inputs so that the output will take all the inputs of the different runs into account. It can be used to save memory. For example, a large time scoping can be split in smaller ranges of time to compute the result range by range.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: accumulate_level_over_label_fc
  • full name: math.accumulate_level_over_label_fc
  • internal name: accumulate_level_over_label_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.accumulate_level_over_label_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.label.Connect(my_label)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.accumulate_level_over_label_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.label.connect(my_label)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("accumulate_level_over_label_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_label);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: make for each range

Description

Generate a range that can be consumed by the for_each operator

Inputs

pin -1optional
try_generate_iterablename
(bool)expected type(s)

if true, already iterable values connected in pin 3 like vectors, Scoping, TimefreqSupport, Containers and DataSources are split to iterate on it (default is true)

pin 0optional
iterablename

Iterable object, generated by make_for_each_range oeprator, that can be combined with the one currently generated.

pin 1requested
operator_to_iteratename
(operator)expected type(s)

Operator that must be reconnected with the range values.

pin 2requested
pin_indexname
(int32)expected type(s)
pin 3requested
valueAname
pin 4requested
valueBname
pin 5, 6...requested, ellipsis
valueCname

Outputs

pin 0requested
outputname

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: make_for_each_range
  • full name: utility.make_for_each_range
  • internal name: make_for_each_range
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.make_for_each_range() # operator instantiation
op.inputs.try_generate_iterable.Connect(my_try_generate_iterable)
op.inputs.iterable.Connect(my_iterable)
op.inputs.operator_to_iterate.Connect(my_operator_to_iterate)
op.inputs.pin_index.Connect(my_pin_index)
op.inputs.valueA.Connect(my_valueA)
op.inputs.valueB.Connect(my_valueB)
op.inputs.valueC1.Connect(my_valueC_1)
op.inputs.valueC2.Connect(my_valueC_2)
my_output = op.outputs.output.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.make_for_each_range() # operator instantiation
op.inputs.try_generate_iterable.connect(my_try_generate_iterable)
op.inputs.iterable.connect(my_iterable)
op.inputs.operator_to_iterate.connect(my_operator_to_iterate)
op.inputs.pin_index.connect(my_pin_index)
op.inputs.valueA.connect(my_valueA)
op.inputs.valueB.connect(my_valueB)
op.inputs.valueC1.connect(my_valueC_1)
op.inputs.valueC2.connect(my_valueC_2)
my_output = op.outputs.output()
#include "dpf_api.h"

ansys::dpf::Operator op("make_for_each_range"); // operator instantiation
op.connect(-1, my_try_generate_iterable);
op.connect(0, my_iterable);
op.connect(1, my_operator_to_iterate);
op.connect(2, my_pin_index);
op.connect(3, my_valueA);
op.connect(4, my_valueB);
op.connect(5, my_valueC_1);
op.connect(6, my_valueC_2);
ansys::dpf::Any my_output = op.getOutput<ansys::dpf::Any>(0);

utility: incremental field

Description

Incrementaly merge the input.

Inputs

pin 0requested
inputname
(field)expected type(s)

Outputs

pin 0requested
incremented_resultname

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: field
  • full name: utility.field
  • internal name: incremental::merge::field
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.field() # operator instantiation
op.inputs.input.Connect(my_input)
my_incremented_result = op.outputs.incremented_result.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.field() # operator instantiation
op.inputs.input.connect(my_input)
my_incremented_result = op.outputs.incremented_result()
#include "dpf_api.h"

ansys::dpf::Operator op("incremental::merge::field"); // operator instantiation
op.connect(0, my_input);
ansys::dpf::Any my_incremented_result = op.getOutput<ansys::dpf::Any>(0);

utility: incremental fields container

Description

Incrementaly merge the input.

Inputs

pin 0requested
inputname
(fields_container)expected type(s)

Outputs

pin 0requested
incremented_resultname

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: fields_container
  • full name: utility.fields_container
  • internal name: incremental::merge::fields_container
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.fields_container() # operator instantiation
op.inputs.input.Connect(my_input)
my_incremented_result = op.outputs.incremented_result.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.fields_container() # operator instantiation
op.inputs.input.connect(my_input)
my_incremented_result = op.outputs.incremented_result()
#include "dpf_api.h"

ansys::dpf::Operator op("incremental::merge::fields_container"); // operator instantiation
op.connect(0, my_input);
ansys::dpf::Any my_incremented_result = op.getOutput<ansys::dpf::Any>(0);

geo: rotate (fields container)

Description

Apply a transformation (rotation) matrix on all the fields of a fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
coordinate_systemname
(field)expected type(s)

3-3 rotation matrix

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: geo
  • plugin: core
  • scripting name: rotate_fc
  • full name: geo.rotate_fc
  • internal name: rotate_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.rotate_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.coordinate_system.Connect(my_coordinate_system)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.rotate_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.coordinate_system.connect(my_coordinate_system)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("rotate_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_coordinate_system);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: incremental property field

Description

Incrementaly merge the input.

Inputs

pin 0requested
inputname
(property_field)expected type(s)

Outputs

pin 0requested
incremented_resultname

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: property_field
  • full name: utility.property_field
  • internal name: incremental::merge::property_field
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.property_field() # operator instantiation
op.inputs.input.Connect(my_input)
my_incremented_result = op.outputs.incremented_result.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.property_field() # operator instantiation
op.inputs.input.connect(my_input)
my_incremented_result = op.outputs.incremented_result()
#include "dpf_api.h"

ansys::dpf::Operator op("incremental::merge::property_field"); // operator instantiation
op.connect(0, my_input);
ansys::dpf::Any my_incremented_result = op.getOutput<ansys::dpf::Any>(0);

mesh: points from coordinates

Description

Extract a mesh made of points elements. This mesh is made from input meshes coordinates on the input scopings.

Inputs

pin 0requested
nodes_to_keepname
(scoping | scopings_container)expected type(s)
pin 1requested
meshname
(abstract_meshed_region | meshes_container)expected type(s)

Outputs

pin 0requested
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: points_from_coordinates
  • full name: mesh.points_from_coordinates
  • internal name: mesh::points_from_coordinates
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.points_from_coordinates() # operator instantiation
op.inputs.nodes_to_keep.Connect(my_nodes_to_keep)
op.inputs.mesh.Connect(my_mesh)
my_abstract_meshed_region = op.outputs.abstract_meshed_region.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.points_from_coordinates() # operator instantiation
op.inputs.nodes_to_keep.connect(my_nodes_to_keep)
op.inputs.mesh.connect(my_mesh)
my_abstract_meshed_region = op.outputs.abstract_meshed_region()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh::points_from_coordinates"); // operator instantiation
op.connect(0, my_nodes_to_keep);
op.connect(1, my_mesh);
ansys::dpf::MeshedRegion my_abstract_meshed_region = op.getOutput<ansys::dpf::MeshedRegion>(0);

utility: incremental mesh

Description

Incrementaly merge the input.

Inputs

pin 0requested
inputname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
incremented_resultname

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: mesh
  • full name: utility.mesh
  • internal name: incremental::merge::mesh
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.mesh() # operator instantiation
op.inputs.input.Connect(my_input)
my_incremented_result = op.outputs.incremented_result.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.mesh() # operator instantiation
op.inputs.input.connect(my_input)
my_incremented_result = op.outputs.incremented_result()
#include "dpf_api.h"

ansys::dpf::Operator op("incremental::merge::mesh"); // operator instantiation
op.connect(0, my_input);
ansys::dpf::Any my_incremented_result = op.getOutput<ansys::dpf::Any>(0);

utility: incremental concantenate as fields container.

Description

Assemble fields in a fields container.

Inputs

pin 0requested
fieldname
(field)expected type(s)
pin 1optional
labelname
(label_space)expected type(s)

Label space value that must be applied to the added field.

Outputs

pin 0requested
outputname
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: incremental_concatenate_as_fc
  • full name: utility.incremental_concatenate_as_fc
  • internal name: incremental::concatenate_as_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.incremental_concatenate_as_fc() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.label.Connect(my_label)
my_output = op.outputs.output.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.incremental_concatenate_as_fc() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.label.connect(my_label)
my_output = op.outputs.output()
#include "dpf_api.h"

ansys::dpf::Operator op("incremental::concatenate_as_fc"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_label);
ansys::dpf::FieldsContainer my_output = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: make producer consumer for each iterator

Description

Generates an iterator that can be consumed by the for_each operator.The chain of Operators are split into a first part : the producers and a second part : the consumers.Asynchronous buffers are indeed to connect the producers and the consumers.

Inputs

pin -1optional
try_generate_iterablename
(bool)expected type(s)

if true, already iterable values connected in pin 3 like vectors, Scoping, TimefreqSupport, Containers and DataSources are split to iterate on it (default is true)

pin 0optional
iterablename

Iterable object, generated by make_for_each_range oeprator, that can be combined with the one currently generated.

pin 1requested
operator_to_iteratename
(operator)expected type(s)

Operator that must be reconnected with the range values.

pin 2requested
pin_indexname
(int32)expected type(s)
pin 3requested
valueAname
pin 4requested
valueBname
pin 5, 6...requested, ellipsis
valueCname
pin 1000, 1001...requested, ellipsis
producer_op1name
(operator)expected type(s)
pin 1001, 1002...requested, ellipsis
output_pin_of_producer_op1name
(int32)expected type(s)
pin 1002, 1003...requested, ellipsis
input_pin_of_consumer_op1name
(int32)expected type(s)
pin 1003, 1004...requested, ellipsis
consumer_op1name
(operator)expected type(s)

Outputs

pin 0requested
iteratorname

to connect to producer_consumer_for_each

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: make_producer_consumer_for_each_iterator
  • full name: utility.make_producer_consumer_for_each_iterator
  • internal name: make_producer_consumer_for_each_iterator
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.make_producer_consumer_for_each_iterator() # operator instantiation
op.inputs.try_generate_iterable.Connect(my_try_generate_iterable)
op.inputs.iterable.Connect(my_iterable)
op.inputs.operator_to_iterate.Connect(my_operator_to_iterate)
op.inputs.pin_index.Connect(my_pin_index)
op.inputs.valueA.Connect(my_valueA)
op.inputs.valueB.Connect(my_valueB)
op.inputs.valueC1.Connect(my_valueC_1)
op.inputs.valueC2.Connect(my_valueC_2)
op.inputs.producer_op11.Connect(my_producer_op1_1)
op.inputs.producer_op12.Connect(my_producer_op1_2)
op.inputs.output_pin_of_producer_op11.Connect(my_output_pin_of_producer_op1_1)
op.inputs.output_pin_of_producer_op12.Connect(my_output_pin_of_producer_op1_2)
op.inputs.input_pin_of_consumer_op11.Connect(my_input_pin_of_consumer_op1_1)
op.inputs.input_pin_of_consumer_op12.Connect(my_input_pin_of_consumer_op1_2)
op.inputs.consumer_op11.Connect(my_consumer_op1_1)
op.inputs.consumer_op12.Connect(my_consumer_op1_2)
my_iterator = op.outputs.iterator.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.make_producer_consumer_for_each_iterator() # operator instantiation
op.inputs.try_generate_iterable.connect(my_try_generate_iterable)
op.inputs.iterable.connect(my_iterable)
op.inputs.operator_to_iterate.connect(my_operator_to_iterate)
op.inputs.pin_index.connect(my_pin_index)
op.inputs.valueA.connect(my_valueA)
op.inputs.valueB.connect(my_valueB)
op.inputs.valueC1.connect(my_valueC_1)
op.inputs.valueC2.connect(my_valueC_2)
op.inputs.producer_op11.connect(my_producer_op1_1)
op.inputs.producer_op12.connect(my_producer_op1_2)
op.inputs.output_pin_of_producer_op11.connect(my_output_pin_of_producer_op1_1)
op.inputs.output_pin_of_producer_op12.connect(my_output_pin_of_producer_op1_2)
op.inputs.input_pin_of_consumer_op11.connect(my_input_pin_of_consumer_op1_1)
op.inputs.input_pin_of_consumer_op12.connect(my_input_pin_of_consumer_op1_2)
op.inputs.consumer_op11.connect(my_consumer_op1_1)
op.inputs.consumer_op12.connect(my_consumer_op1_2)
my_iterator = op.outputs.iterator()
#include "dpf_api.h"

ansys::dpf::Operator op("make_producer_consumer_for_each_iterator"); // operator instantiation
op.connect(-1, my_try_generate_iterable);
op.connect(0, my_iterable);
op.connect(1, my_operator_to_iterate);
op.connect(2, my_pin_index);
op.connect(3, my_valueA);
op.connect(4, my_valueB);
op.connect(5, my_valueC_1);
op.connect(6, my_valueC_2);
op.connect(1000, my_producer_op1_1);
op.connect(1001, my_producer_op1_2);
op.connect(1001, my_output_pin_of_producer_op1_1);
op.connect(1002, my_output_pin_of_producer_op1_2);
op.connect(1002, my_input_pin_of_consumer_op1_1);
op.connect(1003, my_input_pin_of_consumer_op1_2);
op.connect(1003, my_consumer_op1_1);
op.connect(1004, my_consumer_op1_2);

utility: producer consumer for each

Description

Allows to write a loop over operators by connecting data to iterate and by requesting the incrementally output merged.The chain of Operators are split into a first part: the producers and a second part: the consumers. These 2 parts will run asynchronously on 2 threads.

Inputs

pin 0requested
producer_consumer_iterableqname

The result of the make_producer_consumer_for_each_iterator operator.

pin 3, 4...requested, ellipsis
forwardname

output of the last operators of the workflow

Outputs

pin 0requested
emptyname
pin 3, 4...requested, ellipsis
outputname

Configurations

evaluate_inputs_before_runIf this option is set to true, all input pins of the operator will be evaluated before entering the run method to maintain a correct Operator status.
(bool)expected type(s)
falsedefault value
: If this option is set to true, all input pins of the operator will be evaluated before entering the run method to maintain a correct Operator status.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: producer_consumer_for_each
  • full name: utility.producer_consumer_for_each
  • internal name: producer_consumer_for_each
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.producer_consumer_for_each() # operator instantiation
op.inputs.producer_consumer_iterableq.Connect(my_producer_consumer_iterableq)
op.inputs.forward1.Connect(my_forward_1)
op.inputs.forward2.Connect(my_forward_2)
my_empty = op.outputs.empty.GetData()
my_output = op.outputs.output.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.producer_consumer_for_each() # operator instantiation
op.inputs.producer_consumer_iterableq.connect(my_producer_consumer_iterableq)
op.inputs.forward1.connect(my_forward_1)
op.inputs.forward2.connect(my_forward_2)
my_empty = op.outputs.empty()
my_output = op.outputs.output()
#include "dpf_api.h"

ansys::dpf::Operator op("producer_consumer_for_each"); // operator instantiation
op.connect(0, my_producer_consumer_iterableq);
op.connect(3, my_forward_1);
op.connect(4, my_forward_2);
ansys::dpf::Any my_empty = op.getOutput<ansys::dpf::Any>(0);
ansys::dpf::Any my_output = op.getOutput<ansys::dpf::Any>(3);

averaging: extend to mid nodes (field)

Description

Extends an Elemental Nodal or Nodal field defined on corner nodes to a field defined also on the mid nodes.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 7optional
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

inplaceThe output is written over the input to save memory if this configuration is set to true. Only supported for nodal fields in input.
(bool)expected type(s)
falsedefault value
: The output is written over the input to save memory if this configuration is set to true. Only supported for nodal fields in input.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: extend_to_mid_nodes
  • full name: averaging.extend_to_mid_nodes
  • internal name: extend_to_mid_nodes
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.extend_to_mid_nodes() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.mesh.Connect(my_mesh)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.extend_to_mid_nodes() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.mesh.connect(my_mesh)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("extend_to_mid_nodes"); // operator instantiation
op.connect(0, my_field);
op.connect(7, my_mesh);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

mesh: mesh get attribute

Description

Uses the MeshedRegion APIs to return a given attribute of the mesh in input.

Inputs

pin 0requested
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)
pin 1requested
property_namename
(string)expected type(s)

Supported property names are: "connectivity", "reverse_connectivity", "mat", "faces_nodes_connectivity", "elements_faces_connectivity" (or any mesh's property field), "coordinates", "named_selection", "num_named_selections", "named_selection_names", "named_selection_locations", "node_scoping", "element_scoping", "face_scoping"...

pin 2optional
property_identifiername
(int32 | string)expected type(s)

Can be used to get a property at a given index, example: a named selection's number or by name, example: a named selection's name.

Outputs

pin 0requested
propertyname
(scoping | field | property_field | int32 | string_field)expected type(s)

Returns a property field for properties: "connectivity", "reverse_connectivity", "mat", "faces_nodes_connectivity", "elements_faces_connectivity" (or any mesh's property field), a field for property: "coordinates", a scoping for properties:"named_selection", "node_scoping", "element_scoping", "face_scoping", a string field for properties: "named_selection_names", "named_selection_locations" and an int for property: "num_named_selections".

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: mesh_get_attribute
  • full name: mesh.mesh_get_attribute
  • internal name: mesh::get_attribute
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.mesh_get_attribute() # operator instantiation
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.property_name.Connect(my_property_name)
op.inputs.property_identifier.Connect(my_property_identifier)
my_property = op.outputs.property.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.mesh_get_attribute() # operator instantiation
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.property_name.connect(my_property_name)
op.inputs.property_identifier.connect(my_property_identifier)
my_property = op.outputs.property()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh::get_attribute"); // operator instantiation
op.connect(0, my_abstract_meshed_region);
op.connect(1, my_property_name);
op.connect(2, my_property_identifier);
ansys::dpf::Scoping my_property = op.getOutput<ansys::dpf::Scoping>(0);

metadata: time freq support get attribute

Description

Uses the TimeFreqSupport APIs to return a given attribute of the scoping in input.

Inputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1requested
property_namename
(string)expected type(s)

Supported property names are: "time_freqs", "imaginary_freqs", "frequency_tolerance", "set_id", "cummulative_index", "sets_freqs".

pin 2optional
property_identifiername
(int32)expected type(s)

Additional pin for properties "set_id" and "cummulative_index": the step id, for "sets_freqs": the sets scoping.

pin 3optional
property_identifier_2name
(int32)expected type(s)

Additional pin for properties "set_id" and "cummulative_index": the substep id (if none, last substep is considered).

Outputs

pin 0requested
propertyname
(double | field | scoping)expected type(s)

Returns a double for property: "frequency_tolerance", a single-value Scoping for properties for "set_id" and "cummulative_index", and a Field otherwise.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: time_freq_support_get_attribute
  • full name: metadata.time_freq_support_get_attribute
  • internal name: timefreqsupport::get_attribute
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.time_freq_support_get_attribute() # operator instantiation
op.inputs.time_freq_support.Connect(my_time_freq_support)
op.inputs.property_name.Connect(my_property_name)
op.inputs.property_identifier.Connect(my_property_identifier)
op.inputs.property_identifier_2.Connect(my_property_identifier_2)
my_property = op.outputs.property.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.time_freq_support_get_attribute() # operator instantiation
op.inputs.time_freq_support.connect(my_time_freq_support)
op.inputs.property_name.connect(my_property_name)
op.inputs.property_identifier.connect(my_property_identifier)
op.inputs.property_identifier_2.connect(my_property_identifier_2)
my_property = op.outputs.property()
#include "dpf_api.h"

ansys::dpf::Operator op("timefreqsupport::get_attribute"); // operator instantiation
op.connect(0, my_time_freq_support);
op.connect(1, my_property_name);
op.connect(2, my_property_identifier);
op.connect(3, my_property_identifier_2);
double my_property = op.getOutput<double>(0);

utility: set attribute

Description

Uses the FieldsContainer APIs to modify it.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
property_namename
(string)expected type(s)

Supported property names are: "labels".

pin 2optional
property_identifiername
(vector | label_space)expected type(s)

Value of the property to be set : vector of string or LabelSpace for "labels".

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Returns the modified FieldsContainer.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: set_attribute
  • full name: utility.set_attribute
  • internal name: fieldscontainer::set_attribute
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.set_attribute() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.property_name.Connect(my_property_name)
op.inputs.property_identifier.Connect(my_property_identifier)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.set_attribute() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.property_name.connect(my_property_name)
op.inputs.property_identifier.connect(my_property_identifier)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("fieldscontainer::set_attribute"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_property_name);
op.connect(2, my_property_identifier);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

utility: field get attribute

Description

A Field in pin 0 and a property name (string) in pin 1 are expected in input.

Inputs

pin 0requested
fieldname
(field)expected type(s)
pin 1requested
property_namename
(string)expected type(s)

Accepted inputs are: 'time_freq_support', 'scoping' and 'header'.

Outputs

pin 0requested
propertyname
(time_freq_support | scoping | abstract_data_tree)expected type(s)

Property value.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: field_get_attribute
  • full name: utility.field_get_attribute
  • internal name: field::get_attribute
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.field_get_attribute() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.property_name.Connect(my_property_name)
my_property = op.outputs.property.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.field_get_attribute() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.property_name.connect(my_property_name)
my_property = op.outputs.property()
#include "dpf_api.h"

ansys::dpf::Operator op("field::get_attribute"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_property_name);
ansys::dpf::TimeFreqSupport my_property = op.getOutput<ansys::dpf::TimeFreqSupport>(0);

min_max: time of min

Description

Evaluates time/frequency of minimum.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 3optional
abs_valuename
(bool)expected type(s)

Should use absolute value.

pin 4optional
compute_amplitudename
(bool)expected type(s)

Do calculate amplitude.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: time_of_min_by_entity
  • full name: min_max.time_of_min_by_entity
  • internal name: time_of_min_by_entity
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.time_of_min_by_entity() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.abs_value.Connect(my_abs_value)
op.inputs.compute_amplitude.Connect(my_compute_amplitude)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.time_of_min_by_entity() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.abs_value.connect(my_abs_value)
op.inputs.compute_amplitude.connect(my_compute_amplitude)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("time_of_min_by_entity"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(3, my_abs_value);
op.connect(4, my_compute_amplitude);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

min_max: max over phase

Description

Returns, for each entity, the maximum value of (real value * cos(theta) - imaginary value * sin(theta)) for theta in [0, 360]degrees with the increment in input.

Inputs

pin 0requested
real_fieldname
(field)expected type(s)
pin 1requested
imaginary_fieldname
(field)expected type(s)
pin 2optional
abs_valuename
(bool)expected type(s)

Should use absolute value.

pin 3optional
phase_incrementname
(double)expected type(s)

Phase increment (default is 10.0 degrees).

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: max_over_phase
  • full name: min_max.max_over_phase
  • internal name: max_over_phase
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.max_over_phase() # operator instantiation
op.inputs.real_field.Connect(my_real_field)
op.inputs.imaginary_field.Connect(my_imaginary_field)
op.inputs.abs_value.Connect(my_abs_value)
op.inputs.phase_increment.Connect(my_phase_increment)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.max_over_phase() # operator instantiation
op.inputs.real_field.connect(my_real_field)
op.inputs.imaginary_field.connect(my_imaginary_field)
op.inputs.abs_value.connect(my_abs_value)
op.inputs.phase_increment.connect(my_phase_increment)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("max_over_phase"); // operator instantiation
op.connect(0, my_real_field);
op.connect(1, my_imaginary_field);
op.connect(2, my_abs_value);
op.connect(3, my_phase_increment);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

min_max: phase of max

Description

Evaluates phase of maximum.

Inputs

pin 0requested
real_fieldname
(field)expected type(s)
pin 1requested
imaginary_fieldname
(field)expected type(s)
pin 2optional
abs_valuename
(bool)expected type(s)

Should use absolute value.

pin 3requested
phase_incrementname
(double)expected type(s)

Phase increment.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: phase_of_max
  • full name: min_max.phase_of_max
  • internal name: phase_of_max
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.phase_of_max() # operator instantiation
op.inputs.real_field.Connect(my_real_field)
op.inputs.imaginary_field.Connect(my_imaginary_field)
op.inputs.abs_value.Connect(my_abs_value)
op.inputs.phase_increment.Connect(my_phase_increment)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.phase_of_max() # operator instantiation
op.inputs.real_field.connect(my_real_field)
op.inputs.imaginary_field.connect(my_imaginary_field)
op.inputs.abs_value.connect(my_abs_value)
op.inputs.phase_increment.connect(my_phase_increment)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("phase_of_max"); // operator instantiation
op.connect(0, my_real_field);
op.connect(1, my_imaginary_field);
op.connect(2, my_abs_value);
op.connect(3, my_phase_increment);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: voigt to standard strains

Description

Converts the strain field from Voigt notation into standard format.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: strain_from_voigt
  • full name: utility.strain_from_voigt
  • internal name: strain_from_voigt
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.strain_from_voigt() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.strain_from_voigt() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("strain_from_voigt"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: voigt to standard strains (fields container)

Description

Converts the strain field from Voigt notation into standard format.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: strain_from_voigt_fc
  • full name: utility.strain_from_voigt_fc
  • internal name: strain_from_voigt_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.strain_from_voigt_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.strain_from_voigt_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("strain_from_voigt_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

min_max: incremental over field

Description

Compute the component-wise minimum (out 0) and maximum (out 1) over coming fields.

Inputs

pin 0requested
fieldname
(field)expected type(s)
pin 17optional
domain_idname
(int32)expected type(s)

Outputs

pin 0requested
field_minname
(field)expected type(s)
pin 1requested
field_maxname
(field)expected type(s)
pin 2requested
domain_ids_minname
(scoping)expected type(s)
pin 3requested
domain_ids_maxname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: min_max
  • plugin: core
  • scripting name: min_max_inc
  • full name: min_max.min_max_inc
  • internal name: min_max_inc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.min_max.min_max_inc() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.domain_id.Connect(my_domain_id)
my_field_min = op.outputs.field_min.GetData()
my_field_max = op.outputs.field_max.GetData()
my_domain_ids_min = op.outputs.domain_ids_min.GetData()
my_domain_ids_max = op.outputs.domain_ids_max.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.min_max.min_max_inc() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.domain_id.connect(my_domain_id)
my_field_min = op.outputs.field_min()
my_field_max = op.outputs.field_max()
my_domain_ids_min = op.outputs.domain_ids_min()
my_domain_ids_max = op.outputs.domain_ids_max()
#include "dpf_api.h"

ansys::dpf::Operator op("min_max_inc"); // operator instantiation
op.connect(0, my_field);
op.connect(17, my_domain_id);
ansys::dpf::Field my_field_min = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_field_max = op.getOutput<ansys::dpf::Field>(1);
ansys::dpf::Scoping my_domain_ids_min = op.getOutput<ansys::dpf::Scoping>(2);
ansys::dpf::Scoping my_domain_ids_max = op.getOutput<ansys::dpf::Scoping>(3);

logic: same meshes?

Description

Takes two meshes and compares them. Note: When comparing mesh properties, the current behaviour is to verify that the properties in the first mesh (pin 0) are included in the second mesh (pin 1).

Inputs

pin 0requested
meshAname
(abstract_meshed_region)expected type(s)
pin 1requested
meshBname
(abstract_meshed_region)expected type(s)
pin 2optional
small_valuename
(double)expected type(s)

define what is a small value for numeric comparison (default value:1.0e-14).

pin 3optional
tolerancename
(double)expected type(s)

define the relative tolerance ceil for numeric comparison (default is 0.001).

pin 4requested
compare_auxiliaryname
(bool)expected type(s)

compare auxiliary data (i.e property fields, scopings...). Default value is 'false'.

Outputs

pin 0requested
are_identicalname
(bool)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: identical_meshes
  • full name: logic.identical_meshes
  • internal name: compare::mesh
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.identical_meshes() # operator instantiation
op.inputs.meshA.Connect(my_meshA)
op.inputs.meshB.Connect(my_meshB)
op.inputs.small_value.Connect(my_small_value)
op.inputs.tolerance.Connect(my_tolerance)
op.inputs.compare_auxiliary.Connect(my_compare_auxiliary)
my_are_identical = op.outputs.are_identical.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.identical_meshes() # operator instantiation
op.inputs.meshA.connect(my_meshA)
op.inputs.meshB.connect(my_meshB)
op.inputs.small_value.connect(my_small_value)
op.inputs.tolerance.connect(my_tolerance)
op.inputs.compare_auxiliary.connect(my_compare_auxiliary)
my_are_identical = op.outputs.are_identical()
#include "dpf_api.h"

ansys::dpf::Operator op("compare::mesh"); // operator instantiation
op.connect(0, my_meshA);
op.connect(1, my_meshB);
op.connect(2, my_small_value);
op.connect(3, my_tolerance);
op.connect(4, my_compare_auxiliary);
bool my_are_identical = op.getOutput<bool>(0);

logic: same fields?

Description

Check if two fields are identical.

Inputs

pin 0requested
fieldAname
(field)expected type(s)
pin 1requested
fieldBname
(field)expected type(s)
pin 2optional
double_valuename
(double)expected type(s)

Double positive small value. Smallest value considered during the comparison step. All the absolute values in the field less than this value are considered null, (default value: 1.0e-14).

pin 3optional
double_tolerancename
(double)expected type(s)

Double relative tolerance. Maximum tolerance gap between two compared values. Values within relative tolerance are considered identical. Formula is (v1 - v2) / v2 < relativeTol. Default is 0.001.

Outputs

pin 0requested
booleanname
(bool)expected type(s)

bool (true if identical...)

pin 1requested
messagename
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: identical_fields
  • full name: logic.identical_fields
  • internal name: AreFieldsIdentical
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.identical_fields() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
op.inputs.double_value.Connect(my_double_value)
op.inputs.double_tolerance.Connect(my_double_tolerance)
my_boolean = op.outputs.boolean.GetData()
my_message = op.outputs.message.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.identical_fields() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
op.inputs.double_value.connect(my_double_value)
op.inputs.double_tolerance.connect(my_double_tolerance)
my_boolean = op.outputs.boolean()
my_message = op.outputs.message()
#include "dpf_api.h"

ansys::dpf::Operator op("AreFieldsIdentical"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
op.connect(2, my_double_value);
op.connect(3, my_double_tolerance);
bool my_boolean = op.getOutput<bool>(0);
std::string my_message = op.getOutput<std::string>(1);

logic: same scopings?

Description

Check if two scopings are identical.

Inputs

pin 0requested
scopingAname
(scoping)expected type(s)
pin 1requested
scopingBname
(scoping)expected type(s)

Outputs

pin 0requested
booleanname
(bool)expected type(s)

bool (true if identical...)

pin 1requested
messagename
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: identical_scopings
  • full name: logic.identical_scopings
  • internal name: compare::scoping
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.identical_scopings() # operator instantiation
op.inputs.scopingA.Connect(my_scopingA)
op.inputs.scopingB.Connect(my_scopingB)
my_boolean = op.outputs.boolean.GetData()
my_message = op.outputs.message.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.identical_scopings() # operator instantiation
op.inputs.scopingA.connect(my_scopingA)
op.inputs.scopingB.connect(my_scopingB)
my_boolean = op.outputs.boolean()
my_message = op.outputs.message()
#include "dpf_api.h"

ansys::dpf::Operator op("compare::scoping"); // operator instantiation
op.connect(0, my_scopingA);
op.connect(1, my_scopingB);
bool my_boolean = op.getOutput<bool>(0);
std::string my_message = op.getOutput<std::string>(1);

logic: same generic data containers?

Description

Takes two generic data containers and compares them. Supported types: Field, FieldsContainer, Mesh, MeshesContainer, PropertyField, PropertyFieldsContainer, Scoping, ScopingsContainer, StringFieldstandard types (double, int, string, vector of int, doubles, string)Note: all inputs related to fields, mesh, and so on are passed to each property check.

Inputs

pin 0requested
generic_data_containerAname
(generic_data_container)expected type(s)
pin 1requested
generic_data_containerBname
(generic_data_container)expected type(s)
pin 2requested
double_valuename
(double)expected type(s)

Double positive small value. Smallest value considered during the comparison step. All the absolute values in the field less than this value are considered null, (default value: 1.0e-14).

pin 3optional
double_tolerancename
(double)expected type(s)

Double relative tolerance. Maximum tolerance gap between two compared values. Values within relative tolerance are considered identical. Formula is (v1-v2)/v2 < relativeTol. Default is 0.001.

pin 4requested
compare_auxiliaryname
(bool)expected type(s)

For meshes and meshescontainer: compare auxiliary data (i.e property fields, scopings...). Default value is 'false'.

Outputs

pin 0requested
includedname
(bool)expected type(s)

bool (true if belongs...)

pin 1requested
messagename
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: identical_generic_data_containers
  • full name: logic.identical_generic_data_containers
  • internal name: compare::generic_data_container
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.identical_generic_data_containers() # operator instantiation
op.inputs.generic_data_containerA.Connect(my_generic_data_containerA)
op.inputs.generic_data_containerB.Connect(my_generic_data_containerB)
op.inputs.double_value.Connect(my_double_value)
op.inputs.double_tolerance.Connect(my_double_tolerance)
op.inputs.compare_auxiliary.Connect(my_compare_auxiliary)
my_included = op.outputs.included.GetData()
my_message = op.outputs.message.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.identical_generic_data_containers() # operator instantiation
op.inputs.generic_data_containerA.connect(my_generic_data_containerA)
op.inputs.generic_data_containerB.connect(my_generic_data_containerB)
op.inputs.double_value.connect(my_double_value)
op.inputs.double_tolerance.connect(my_double_tolerance)
op.inputs.compare_auxiliary.connect(my_compare_auxiliary)
my_included = op.outputs.included()
my_message = op.outputs.message()
#include "dpf_api.h"

ansys::dpf::Operator op("compare::generic_data_container"); // operator instantiation
op.connect(0, my_generic_data_containerA);
op.connect(1, my_generic_data_containerB);
op.connect(2, my_double_value);
op.connect(3, my_double_tolerance);
op.connect(4, my_compare_auxiliary);
bool my_included = op.getOutput<bool>(0);
std::string my_message = op.getOutput<std::string>(1);

logic: same fields container?

Description

Checks if two fields_container are identical.

Inputs

pin 0requested
fields_containerAname
(fields_container)expected type(s)
pin 1requested
fields_containerBname
(fields_container)expected type(s)
pin 2optional
small_valuename
(double)expected type(s)

Double positive small value. Smallest value which will be considered during the comparison step. All the abs(values) in the field less than this value are considered as null, (default value:1.0e-14).

pin 3optional
tolerancename
(double)expected type(s)

Double relative tolerance. Maximum tolerance gap between two compared values. Values within relative tolerance are considered identical (v1-v2)/v2 < relativeTol (default is 0.001).

Outputs

pin 0requested
booleanname
(bool)expected type(s)

bool (true if identical...)

pin 1requested
messagename
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: identical_fc
  • full name: logic.identical_fc
  • internal name: AreFieldsIdentical_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.identical_fc() # operator instantiation
op.inputs.fields_containerA.Connect(my_fields_containerA)
op.inputs.fields_containerB.Connect(my_fields_containerB)
op.inputs.small_value.Connect(my_small_value)
op.inputs.tolerance.Connect(my_tolerance)
my_boolean = op.outputs.boolean.GetData()
my_message = op.outputs.message.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.identical_fc() # operator instantiation
op.inputs.fields_containerA.connect(my_fields_containerA)
op.inputs.fields_containerB.connect(my_fields_containerB)
op.inputs.small_value.connect(my_small_value)
op.inputs.tolerance.connect(my_tolerance)
my_boolean = op.outputs.boolean()
my_message = op.outputs.message()
#include "dpf_api.h"

ansys::dpf::Operator op("AreFieldsIdentical_fc"); // operator instantiation
op.connect(0, my_fields_containerA);
op.connect(1, my_fields_containerB);
op.connect(2, my_small_value);
op.connect(3, my_tolerance);
bool my_boolean = op.getOutput<bool>(0);
std::string my_message = op.getOutput<std::string>(1);

logic: same scopings container?

Description

Checks if two scopings_container are identical.

Inputs

pin 0requested
scopings_containerAname
(scopings_container)expected type(s)
pin 1requested
scopings_containerBname
(scopings_container)expected type(s)

Outputs

pin 0requested
booleanname
(bool)expected type(s)

bool (true if identical...)

pin 1requested
messagename
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: identical_sc
  • full name: logic.identical_sc
  • internal name: compare::scopings_container
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.identical_sc() # operator instantiation
op.inputs.scopings_containerA.Connect(my_scopings_containerA)
op.inputs.scopings_containerB.Connect(my_scopings_containerB)
my_boolean = op.outputs.boolean.GetData()
my_message = op.outputs.message.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.identical_sc() # operator instantiation
op.inputs.scopings_containerA.connect(my_scopings_containerA)
op.inputs.scopings_containerB.connect(my_scopings_containerB)
my_boolean = op.outputs.boolean()
my_message = op.outputs.message()
#include "dpf_api.h"

ansys::dpf::Operator op("compare::scopings_container"); // operator instantiation
op.connect(0, my_scopings_containerA);
op.connect(1, my_scopings_containerB);
bool my_boolean = op.getOutput<bool>(0);
std::string my_message = op.getOutput<std::string>(1);

logic: fields included?

Description

Checks if one field belongs to another.

Inputs

pin 0requested
fieldAname
(field)expected type(s)
pin 1requested
fieldBname
(field)expected type(s)
pin 2requested
double_valuename
(double)expected type(s)

Double positive small value. Smallest value considered during the comparison step. All the absolute values in the field less than this value are considered null, (default value: 1.0e-14).

pin 3optional
double_tolerancename
(double)expected type(s)

Double relative tolerance. Maximum tolerance gap between two compared values. Values within relative tolerance are considered identical. Formula is (v1-v2)/v2 < relativeTol. Default is 0.001.

Outputs

pin 0requested
includedname
(bool)expected type(s)

bool (true if belongs...)

pin 1requested
messagename
(string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: included_fields
  • full name: logic.included_fields
  • internal name: Are_fields_included
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.included_fields() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
op.inputs.double_value.Connect(my_double_value)
op.inputs.double_tolerance.Connect(my_double_tolerance)
my_included = op.outputs.included.GetData()
my_message = op.outputs.message.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.included_fields() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
op.inputs.double_value.connect(my_double_value)
op.inputs.double_tolerance.connect(my_double_tolerance)
my_included = op.outputs.included()
my_message = op.outputs.message()
#include "dpf_api.h"

ansys::dpf::Operator op("Are_fields_included"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
op.connect(2, my_double_value);
op.connect(3, my_double_tolerance);
bool my_included = op.getOutput<bool>(0);
std::string my_message = op.getOutput<std::string>(1);

filter: high pass (scoping)

Description

The high pass filter returns all the values above (but not equal to) the threshold value in input.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
thresholdname
(double | field)expected type(s)

A threshold scalar or a field containing one value is expected.

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: scoping_high_pass
  • full name: filter.scoping_high_pass
  • internal name: core::scoping::high_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.scoping_high_pass() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.scoping_high_pass() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("core::scoping::high_pass"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(0);

filter: high pass (timescoping)

Description

The high pass filter returns all the values above (but not equal to) the threshold value in input.

Inputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1requested
thresholdname
(double | field)expected type(s)

A threshold scalar or a field containing one value is expected.

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: timescoping_high_pass
  • full name: filter.timescoping_high_pass
  • internal name: core::timescoping::high_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.timescoping_high_pass() # operator instantiation
op.inputs.time_freq_support.Connect(my_time_freq_support)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.timescoping_high_pass() # operator instantiation
op.inputs.time_freq_support.connect(my_time_freq_support)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("core::timescoping::high_pass"); // operator instantiation
op.connect(0, my_time_freq_support);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(0);

filter: low pass (field)

Description

The low pass filter returns all the values below (but not equal to) the threshold value in input.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
thresholdname
(double | field)expected type(s)

a threshold scalar or a field containing one value is expected

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: field_low_pass
  • full name: filter.field_low_pass
  • internal name: core::field::low_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.field_low_pass() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.field_low_pass() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("core::field::low_pass"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

filter: low pass (fields container)

Description

The low pass filter returns all the values below (but not equal to) the threshold value in input.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
thresholdname
(double | field)expected type(s)

a threshold scalar or a field containing one value is expected

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: field_low_pass_fc
  • full name: filter.field_low_pass_fc
  • internal name: core::field::low_pass_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.field_low_pass_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.field_low_pass_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("core::field::low_pass_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

filter: band pass (scoping)

Description

The band pass filter returns all the values above (but not equal to) the minimum threshold value and below (but not equal to) the maximum threshold value in input.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
min_thresholdname
(double | field)expected type(s)

A minimum threshold scalar or a field containing one value is expected.

pin 2optional
max_thresholdname
(double | field)expected type(s)

A maximum threshold scalar or a field containing one value is expected.

Outputs

pin 0requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: scoping_band_pass
  • full name: filter.scoping_band_pass
  • internal name: core::scoping::band_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.scoping_band_pass() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.min_threshold.Connect(my_min_threshold)
op.inputs.max_threshold.Connect(my_max_threshold)
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.scoping_band_pass() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.min_threshold.connect(my_min_threshold)
op.inputs.max_threshold.connect(my_max_threshold)
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("core::scoping::band_pass"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_min_threshold);
op.connect(2, my_max_threshold);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(0);

filter: signed high pass (scoping)

Description

The high pass filter returns all the values above, or equal, in absolute value to the threshold value in input.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
thresholdname
(double | field)expected type(s)

A threshold scalar or a field containing one value is expected.

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: scoping_signed_high_pass
  • full name: filter.scoping_signed_high_pass
  • internal name: core::scoping::signed_high_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.scoping_signed_high_pass() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.scoping_signed_high_pass() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("core::scoping::signed_high_pass"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(0);

filter: signed high pass (timescoping)

Description

The high pass filter returns all the values above, or equal, in absolute value to the threshold value in input.

Inputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1requested
thresholdname
(double | field)expected type(s)

A threshold scalar or a field containing one value is expected.

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: timescoping_signed_high_pass
  • full name: filter.timescoping_signed_high_pass
  • internal name: core::timescoping::signed_high_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.timescoping_signed_high_pass() # operator instantiation
op.inputs.time_freq_support.Connect(my_time_freq_support)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.timescoping_signed_high_pass() # operator instantiation
op.inputs.time_freq_support.connect(my_time_freq_support)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("core::timescoping::signed_high_pass"); // operator instantiation
op.connect(0, my_time_freq_support);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(0);

filter: signed high pass (timefreq)

Description

The high pass filter returns all the values above, or equal, in absolute value to the threshold value in input.

Inputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1requested
thresholdname
(double | field)expected type(s)

A threshold scalar or a field containing one value is expected.

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: timefreq_signed_high_pass
  • full name: filter.timefreq_signed_high_pass
  • internal name: core::timefreq::signed_high_pass
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.timefreq_signed_high_pass() # operator instantiation
op.inputs.time_freq_support.Connect(my_time_freq_support)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_time_freq_support = op.outputs.time_freq_support.GetData()
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.timefreq_signed_high_pass() # operator instantiation
op.inputs.time_freq_support.connect(my_time_freq_support)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_time_freq_support = op.outputs.time_freq_support()
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("core::timefreq::signed_high_pass"); // operator instantiation
op.connect(0, my_time_freq_support);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::TimeFreqSupport my_time_freq_support = op.getOutput<ansys::dpf::TimeFreqSupport>(0);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(1);

filter: signed high pass (fields container)

Description

The high pass filter returns all the values above, or equal, in absolute value to the threshold value in input.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
thresholdname
(double | field)expected type(s)

A threshold scalar or a field containing one value is expected.

pin 2optional
bothname
(bool)expected type(s)

The default is false. If set to true, the complement of the filtered fields container is returned on output pin 1.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: field_signed_high_pass_fc
  • full name: filter.field_signed_high_pass_fc
  • internal name: core::field::signed_high_pass_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.field_signed_high_pass_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.threshold.Connect(my_threshold)
op.inputs.both.Connect(my_both)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.field_signed_high_pass_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.threshold.connect(my_threshold)
op.inputs.both.connect(my_both)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("core::field::signed_high_pass_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_threshold);
op.connect(2, my_both);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: csv to field

Description

transform csv file to a field or fields container

Inputs

pin 0optional
time_scopingname
(scoping)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)

data sources containing a file with csv extension

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: csv
  • scripting name: csv_to_field
  • full name: serialization.csv_to_field
  • internal name: csv_to_field
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.csv_to_field() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.data_sources.Connect(my_data_sources)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.csv_to_field() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.data_sources.connect(my_data_sources)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("csv_to_field"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: members in compression not certified

Description

This operator is a non-certified example of buckling resistance verification for the compression members for Class I, 2 and 3 cross-sections. It is only provided as an example if you want to develop your own compute norm operator. The results computed by this beta operator have not been certified by ANSYS. ANSYS declines all responsibility for the use of this operator.

Inputs

pin 0optional
time_scopingname
(scoping | vector | int32)expected type(s)

time/freq set ids (use ints or scoping)

pin 1requested
field_yield_strengthname
(data_sources | field)expected type(s)

This pin contains file csv or field of beam's Yield Strength.

pin 2requested
field_end_conditionname
(data_sources | field)expected type(s)

This pin contains file csv or field of beam's end condition defined by the user. If no input at this pin found, it would take end condition's value of all beams as 1.

pin 3optional
streamsname
(streams_container)expected type(s)

result file container allowed to be kept open to cache data.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set.

pin 5requested
manufacturename
(bool)expected type(s)

Manufacturing processus:hot finished if TRUE or cold formed if FALSE. Default value : hot finished.

pin 6requested
partial_factorname
(double)expected type(s)

partial safety factor for resistance of members to instability assessed by member checks. Default value: 1.

pin 7requested
meshname
(abstract_meshed_region)expected type(s)

Mesh containing beam's properties defined by user

pin 8requested
axial_forcename
(fields_container)expected type(s)

Fields Container of axial force defined by user

pin 12requested
fabrication_typename
(bool)expected type(s)

If there is beam I in the structure, please define its fabrication type. True: Rolled section, False: Welded section

Outputs

pin 0requested
buckling_resistance_compression_yyname
(fields_container)expected type(s)

Fields Container of buckling resistance factor on axis y-y in case of compression. These factors should be less than 1 and positive.

pin 1requested
buckling_resistance_compression_zzname
(fields_container)expected type(s)

Fields Container of buckling resistance factor on axis z-z in case of compression. These factors should be less than 1 and positive.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: members_in_compression_not_certified
  • full name: result.members_in_compression_not_certified
  • internal name: members_in_compression_not_certified
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.members_in_compression_not_certified() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.field_yield_strength.Connect(my_field_yield_strength)
op.inputs.field_end_condition.Connect(my_field_end_condition)
op.inputs.streams.Connect(my_streams)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.manufacture.Connect(my_manufacture)
op.inputs.partial_factor.Connect(my_partial_factor)
op.inputs.mesh.Connect(my_mesh)
op.inputs.axial_force.Connect(my_axial_force)
op.inputs.fabrication_type.Connect(my_fabrication_type)
my_buckling_resistance_compression_yy = op.outputs.buckling_resistance_compression_yy.GetData()
my_buckling_resistance_compression_zz = op.outputs.buckling_resistance_compression_zz.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.members_in_compression_not_certified() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.field_yield_strength.connect(my_field_yield_strength)
op.inputs.field_end_condition.connect(my_field_end_condition)
op.inputs.streams.connect(my_streams)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.manufacture.connect(my_manufacture)
op.inputs.partial_factor.connect(my_partial_factor)
op.inputs.mesh.connect(my_mesh)
op.inputs.axial_force.connect(my_axial_force)
op.inputs.fabrication_type.connect(my_fabrication_type)
my_buckling_resistance_compression_yy = op.outputs.buckling_resistance_compression_yy()
my_buckling_resistance_compression_zz = op.outputs.buckling_resistance_compression_zz()
#include "dpf_api.h"

ansys::dpf::Operator op("members_in_compression_not_certified"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_field_yield_strength);
op.connect(2, my_field_end_condition);
op.connect(3, my_streams);
op.connect(4, my_data_sources);
op.connect(5, my_manufacture);
op.connect(6, my_partial_factor);
op.connect(7, my_mesh);
op.connect(8, my_axial_force);
op.connect(12, my_fabrication_type);
ansys::dpf::FieldsContainer my_buckling_resistance_compression_yy = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_buckling_resistance_compression_zz = op.getOutput<ansys::dpf::FieldsContainer>(1);

result: members in bending not certified

Description

This operator is a non-certified example of buckling resistance verification for the bending members. It is only provided as an example if you want to develop your own compute norm operator. The results computed by this beta operator have not been certified by ANSYS. ANSYS declines all responsibility for the use of this operator. HATS Beam and irregular beams (unequal I-Beam, not-square Channel-Beam, not-square Angle L-beam, unequal hollow rectangular beam) not supported.

Inputs

pin 0optional
time_scopingname
(scoping | vector | int32)expected type(s)
pin 1requested
field_yield_strengthname
(field)expected type(s)

This pin contains field of beam's Yield Strength defined by the user.

pin 2requested
class_cross_sectionname
(bool)expected type(s)

Selection for a cross-section. True: Class 1 or 2 cross-sections. False: Class 3 cross section. If the user defines the cross section as class 1 or 2, the section modulus would be plastic section modulus. If it's class 3- cross section,the section modulus would be elastic section modulus

pin 3optional
streamsname
(streams_container)expected type(s)

result file container allowed to be kept open to cache data.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set.

pin 6requested
partial_factorname
(double)expected type(s)

partial safety factor for resistance of members to instability assessed by member checks. Default value: 1.

pin 7requested
meshname
(abstract_meshed_region)expected type(s)

Mesh containing beam's properties defined by user

pin 8requested
bending_moment_yname
(fields_container)expected type(s)

Fields Container of bending moment on axis y defined by user

pin 9requested
bending_moment_zname
(fields_container)expected type(s)

Fields Container of bending moment on axis z defined by user

Outputs

pin 0requested
buckling_resistance_bending_yyname
(fields_container)expected type(s)

Fields Container of buckling resistance factor on axis y-y in case of bending(M). These factors should be less than 1 and positive.

pin 1requested
buckling_resistance_bending_zzname
(fields_container)expected type(s)

Fields Container of buckling resistance factor on axis z-z in case of bending(M). These factors should be less than 1 and positive.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: members_in_bending_not_certified
  • full name: result.members_in_bending_not_certified
  • internal name: members_in_bending_not_certified
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.members_in_bending_not_certified() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.field_yield_strength.Connect(my_field_yield_strength)
op.inputs.class_cross_section.Connect(my_class_cross_section)
op.inputs.streams.Connect(my_streams)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.partial_factor.Connect(my_partial_factor)
op.inputs.mesh.Connect(my_mesh)
op.inputs.bending_moment_y.Connect(my_bending_moment_y)
op.inputs.bending_moment_z.Connect(my_bending_moment_z)
my_buckling_resistance_bending_yy = op.outputs.buckling_resistance_bending_yy.GetData()
my_buckling_resistance_bending_zz = op.outputs.buckling_resistance_bending_zz.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.members_in_bending_not_certified() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.field_yield_strength.connect(my_field_yield_strength)
op.inputs.class_cross_section.connect(my_class_cross_section)
op.inputs.streams.connect(my_streams)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.partial_factor.connect(my_partial_factor)
op.inputs.mesh.connect(my_mesh)
op.inputs.bending_moment_y.connect(my_bending_moment_y)
op.inputs.bending_moment_z.connect(my_bending_moment_z)
my_buckling_resistance_bending_yy = op.outputs.buckling_resistance_bending_yy()
my_buckling_resistance_bending_zz = op.outputs.buckling_resistance_bending_zz()
#include "dpf_api.h"

ansys::dpf::Operator op("members_in_bending_not_certified"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_field_yield_strength);
op.connect(2, my_class_cross_section);
op.connect(3, my_streams);
op.connect(4, my_data_sources);
op.connect(6, my_partial_factor);
op.connect(7, my_mesh);
op.connect(8, my_bending_moment_y);
op.connect(9, my_bending_moment_z);
ansys::dpf::FieldsContainer my_buckling_resistance_bending_yy = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_buckling_resistance_bending_zz = op.getOutput<ansys::dpf::FieldsContainer>(1);

geo: rotate

Description

Applies a transformation (rotation) matrix on a field.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
field_rotation_matrixname
(field)expected type(s)

3-3 rotation matrix

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: geo
  • plugin: core
  • scripting name: rotate
  • full name: geo.rotate
  • internal name: rotate
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.rotate() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.field_rotation_matrix.Connect(my_field_rotation_matrix)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.rotate() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.field_rotation_matrix.connect(my_field_rotation_matrix)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("rotate"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_field_rotation_matrix);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

serialization: data tree to json

Description

Writes a json file or string from a DataTree

Inputs

pin 0requested
data_treename
(abstract_data_tree)expected type(s)
pin 1optional
pathname
(string)expected type(s)

Outputs

pin 0requested
data_sourcesname
(data_sources | string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: data_tree_to_json
  • full name: serialization.data_tree_to_json
  • internal name: data_tree_to_json
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.data_tree_to_json() # operator instantiation
op.inputs.data_tree.Connect(my_data_tree)
op.inputs.path.Connect(my_path)
my_data_sources = op.outputs.data_sources.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.data_tree_to_json() # operator instantiation
op.inputs.data_tree.connect(my_data_tree)
op.inputs.path.connect(my_path)
my_data_sources = op.outputs.data_sources()
#include "dpf_api.h"

ansys::dpf::Operator op("data_tree_to_json"); // operator instantiation
op.connect(0, my_data_tree);
op.connect(1, my_path);
ansys::dpf::DataSources my_data_sources = op.getOutput<ansys::dpf::DataSources>(0);

serialization: data tree to txt

Description

Writes a txt file or string from a DataTree

Inputs

pin 0requested
data_treename
(abstract_data_tree)expected type(s)
pin 1optional
pathname
(string)expected type(s)

Outputs

pin 0requested
data_sourcesname
(data_sources | string)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: data_tree_to_txt
  • full name: serialization.data_tree_to_txt
  • internal name: data_tree_to_txt
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.data_tree_to_txt() # operator instantiation
op.inputs.data_tree.Connect(my_data_tree)
op.inputs.path.Connect(my_path)
my_data_sources = op.outputs.data_sources.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.data_tree_to_txt() # operator instantiation
op.inputs.data_tree.connect(my_data_tree)
op.inputs.path.connect(my_path)
my_data_sources = op.outputs.data_sources()
#include "dpf_api.h"

ansys::dpf::Operator op("data_tree_to_txt"); // operator instantiation
op.connect(0, my_data_tree);
op.connect(1, my_path);
ansys::dpf::DataSources my_data_sources = op.getOutput<ansys::dpf::DataSources>(0);

averaging: nodal difference (fields container)

Description

Transforms Elemental Nodal fields into Nodal fields. Each nodal value is the maximum difference between the unaveraged computed result for all elements that share this particular node. The result is computed on a given node scoping. If the input fields are mixed shell/solid, then the fields are split by element shape and the output fields container has an elshape label.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

The mesh region in this pin is used to perform the averaging. It is used if there is no fields support.

pin 3optional
scopingname
(scoping | scopings_container)expected type(s)

Average only on these nodes. If it is a scoping container, the label must correspond to the one of the fields containers.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: nodal_difference_fc
  • full name: averaging.nodal_difference_fc
  • internal name: nodal_difference_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.nodal_difference_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.scoping.Connect(my_scoping)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.nodal_difference_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.scoping.connect(my_scoping)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("nodal_difference_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(3, my_scoping);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: json to data tree

Description

Reads a json file or string to a DataTree

Inputs

pin 0requested
string_or_pathname
(string | data_sources)expected type(s)

Outputs

pin 0requested
data_treename
(abstract_data_tree)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: json_to_data_tree
  • full name: serialization.json_to_data_tree
  • internal name: json_to_data_tree
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.json_to_data_tree() # operator instantiation
op.inputs.string_or_path.Connect(my_string_or_path)
my_data_tree = op.outputs.data_tree.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.json_to_data_tree() # operator instantiation
op.inputs.string_or_path.connect(my_string_or_path)
my_data_tree = op.outputs.data_tree()
#include "dpf_api.h"

ansys::dpf::Operator op("json_to_data_tree"); // operator instantiation
op.connect(0, my_string_or_path);
ansys::dpf::AbstractDataTree my_data_tree = op.getOutput<ansys::dpf::AbstractDataTree>(0);

logic: descending sort

Description

Sort a field (in 0) in descending order, with an optional component priority table or a boolean to enable sort by scoping (in 1). This operator doesn't support multiple elementary data per entity.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
component_priority_tablename
(vector)expected type(s)

component priority table (vector of int)

pin 2optional
sort_by_scopingname
(bool)expected type(s)

if true, uses scoping to sort the field (default is false)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: descending_sort
  • full name: logic.descending_sort
  • internal name: descending_sort
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.descending_sort() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.component_priority_table.Connect(my_component_priority_table)
op.inputs.sort_by_scoping.Connect(my_sort_by_scoping)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.descending_sort() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.component_priority_table.connect(my_component_priority_table)
op.inputs.sort_by_scoping.connect(my_sort_by_scoping)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("descending_sort"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_component_priority_table);
op.connect(2, my_sort_by_scoping);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

logic: ascending sort (fields container)

Description

Sort a field (in 0) in ascending order with an optional component priority table, or a boolean, to enable sort by scoping (in 1). This operator does not support multiple elementary data per entity.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
component_priority_tablename
(vector)expected type(s)

component priority table (vector of int)

pin 2optional
sort_by_scopingname
(bool)expected type(s)

if true, uses scoping to sort the field (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: ascending_sort_fc
  • full name: logic.ascending_sort_fc
  • internal name: ascending_sort_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.ascending_sort_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.component_priority_table.Connect(my_component_priority_table)
op.inputs.sort_by_scoping.Connect(my_sort_by_scoping)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.ascending_sort_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.component_priority_table.connect(my_component_priority_table)
op.inputs.sort_by_scoping.connect(my_sort_by_scoping)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("ascending_sort_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_component_priority_table);
op.connect(2, my_sort_by_scoping);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

logic: descending sort (fields container)

Description

Sort a field (in 0) in descending order, with an optional component priority table or a boolean to enable sort by scoping (in 1). This operator doesn't support multiple elementary data per entity.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
component_priority_tablename
(vector)expected type(s)

component priority table (vector of int)

pin 2optional
sort_by_scopingname
(bool)expected type(s)

if true, uses scoping to sort the field (default is false)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: descending_sort_fc
  • full name: logic.descending_sort_fc
  • internal name: descending_sort_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.descending_sort_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.component_priority_table.Connect(my_component_priority_table)
op.inputs.sort_by_scoping.Connect(my_sort_by_scoping)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.descending_sort_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.component_priority_table.connect(my_component_priority_table)
op.inputs.sort_by_scoping.connect(my_sort_by_scoping)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("descending_sort_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_component_priority_table);
op.connect(2, my_sort_by_scoping);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: import symbolic workflow

Description

Reads a file or string holding a Symbolic Workflow and instantiate a WorkFlow with its data.

Inputs

pin 0requested
string_or_pathname
(string | data_sources)expected type(s)
pin 2optional
formatname
(int32)expected type(s)

-1 is auto-detection, 0 is ASCII format, 1 is binary, 2 is json, default is -1 (auto-detection).

Outputs

pin 0requested
workflowname
(workflow)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: import_symbolic_workflow
  • full name: serialization.import_symbolic_workflow
  • internal name: import_symbolic_workflow
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.import_symbolic_workflow() # operator instantiation
op.inputs.string_or_path.Connect(my_string_or_path)
op.inputs.format.Connect(my_format)
my_workflow = op.outputs.workflow.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.import_symbolic_workflow() # operator instantiation
op.inputs.string_or_path.connect(my_string_or_path)
op.inputs.format.connect(my_format)
my_workflow = op.outputs.workflow()
#include "dpf_api.h"

ansys::dpf::Operator op("import_symbolic_workflow"); // operator instantiation
op.connect(0, my_string_or_path);
op.connect(2, my_format);
ansys::dpf::Workflow my_workflow = op.getOutput<ansys::dpf::Workflow>(0);

filter: filtering max over time workflow

Description

Creates a filtering workflow that will filter results based on a threshold of a selected invariant.

Inputs

pin 0requested
invariant_fc_operatorname
(string)expected type(s)

Name of the invariant operator to be used to calculate filter (available: eqv_fc, invariants_deriv_fc, invariants_fc).

pin 1optional
output_pinname
(int32)expected type(s)

Output pin of the invariant operator. Default = 0.

pin 2optional
list_of_resultsname
(vector | string)expected type(s)

If no result is given, filter will be applied on Stresses and Strains

pin 3optional
thresholdname
(double)expected type(s)

Threshold from which the operator will filter.

Outputs

pin 0requested
workflowname
(workflow)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: filtering_max_over_time
  • full name: filter.filtering_max_over_time
  • internal name: filtering_max_over_time
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.filtering_max_over_time() # operator instantiation
op.inputs.invariant_fc_operator.Connect(my_invariant_fc_operator)
op.inputs.output_pin.Connect(my_output_pin)
op.inputs.list_of_results.Connect(my_list_of_results)
op.inputs.threshold.Connect(my_threshold)
my_workflow = op.outputs.workflow.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.filtering_max_over_time() # operator instantiation
op.inputs.invariant_fc_operator.connect(my_invariant_fc_operator)
op.inputs.output_pin.connect(my_output_pin)
op.inputs.list_of_results.connect(my_list_of_results)
op.inputs.threshold.connect(my_threshold)
my_workflow = op.outputs.workflow()
#include "dpf_api.h"

ansys::dpf::Operator op("filtering_max_over_time"); // operator instantiation
op.connect(0, my_invariant_fc_operator);
op.connect(1, my_output_pin);
op.connect(2, my_list_of_results);
op.connect(3, my_threshold);
ansys::dpf::Workflow my_workflow = op.getOutput<ansys::dpf::Workflow>(0);

metadata: integrate over time freq

Description

Integration of an input field over timefreq.

Inputs

pin 0requested
fieldname
(field)expected type(s)
pin 1optional
scopingname
(scoping)expected type(s)

Integrate the input field over a specific scoping.

pin 2optional
time_freq_supportname
(time_freq_support)expected type(s)

Time Freq to integrate on, otherwise time freq support from the input field is taken.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: integrate_over_time_freq
  • full name: metadata.integrate_over_time_freq
  • internal name: timefreq::integrate
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.integrate_over_time_freq() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.scoping.Connect(my_scoping)
op.inputs.time_freq_support.Connect(my_time_freq_support)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.integrate_over_time_freq() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.scoping.connect(my_scoping)
op.inputs.time_freq_support.connect(my_time_freq_support)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("timefreq::integrate"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_scoping);
op.connect(2, my_time_freq_support);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

utility: extract time freq

Description

Extract timefreqs with sets scoping from a time freq support

Inputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)
pin 1optional
time_scopingname
(scoping)expected type(s)
pin 2optional
real_or_complexname
(bool)expected type(s)

False for real only (default). True for complex output.

Outputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: extract_time_freq
  • full name: utility.extract_time_freq
  • internal name: extract_time_freq
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.extract_time_freq() # operator instantiation
op.inputs.time_freq_support.Connect(my_time_freq_support)
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.real_or_complex.Connect(my_real_or_complex)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.extract_time_freq() # operator instantiation
op.inputs.time_freq_support.connect(my_time_freq_support)
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.real_or_complex.connect(my_real_or_complex)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("extract_time_freq"); // operator instantiation
op.connect(0, my_time_freq_support);
op.connect(1, my_time_scoping);
op.connect(2, my_real_or_complex);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

averaging: nodal difference (field)

Description

Transforms an Elemental Nodal field into a Nodal field. Each nodal value is the maximum difference between the unaveraged computed result for all elements that share this particular node. The result is computed on a given node's scoping.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
mesh_scopingname
(scoping)expected type(s)

average only on these entities

pin 7optional
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: nodal_difference
  • full name: averaging.nodal_difference
  • internal name: nodal_difference
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.nodal_difference() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.mesh.Connect(my_mesh)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.nodal_difference() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.mesh.connect(my_mesh)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("nodal_difference"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_mesh_scoping);
op.connect(7, my_mesh);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: compute stress YZ

Description

Computes the stress from an elastic strain field. compute_total_strain limitations are applicable for stress computation Get the YZ shear component (12 component).

Inputs

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Needed to get mesh and material ids. Optional if a data_sources have been connected.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

Needed to get mesh and material ids. Optional if a streams_container have been connected.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10requested
strainname
(fields_container | field)expected type(s)

Field/or fields container containing only the elastic strain field (element nodal).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_stress_YZ
  • full name: result.compute_stress_YZ
  • internal name: compute_stress_YZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_stress_YZ() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.strain.Connect(my_strain)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_stress_YZ() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.strain.connect(my_strain)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_stress_YZ"); // operator instantiation
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(9, my_requested_location);
op.connect(10, my_strain);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

logic: splitter::data_sources

Description

Splits a Data Sources into multiple coherent data sources, actual number of outputs is always less or equal to the given desired number of ouputs.

Inputs

pin 0requested
data_sourcesname
(data_sources)expected type(s)

Data sources to split.

pin 1requested
output_countname
(int32)expected type(s)

Number of desired outputs.

Outputs

pin -1requested
output_countname
(int32)expected type(s)

Actual number of outputs.

pin 0, 1...requested, ellipsis
outputsname
(data_sources)expected type(s)

Data sources outputs.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: logic
  • plugin: core
  • scripting name: split_data_sources
  • full name: logic.split_data_sources
  • internal name: splitter::data_sources
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.logic.split_data_sources() # operator instantiation
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.output_count.Connect(my_output_count)
my_output_count = op.outputs.output_count.GetData()
my_outputs = op.outputs.outputs.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.logic.split_data_sources() # operator instantiation
op.inputs.data_sources.connect(my_data_sources)
op.inputs.output_count.connect(my_output_count)
my_output_count = op.outputs.output_count()
my_outputs = op.outputs.outputs()
#include "dpf_api.h"

ansys::dpf::Operator op("splitter::data_sources"); // operator instantiation
op.connect(0, my_data_sources);
op.connect(1, my_output_count);
int my_output_count = op.getOutput<int>(-1);
ansys::dpf::DataSources my_outputs = op.getOutput<ansys::dpf::DataSources>(0);

averaging: to elemental nodal (fields container)

Description

Transforms fields into Elemental Nodal fields using an averaging process. The result is computed on a given element's scoping.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
mesh_scopingname
(scoping)expected type(s)
pin 7optional
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: to_elemental_nodal_fc
  • full name: averaging.to_elemental_nodal_fc
  • internal name: to_elemental_nodal_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.to_elemental_nodal_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.to_elemental_nodal_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("to_elemental_nodal_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh_scoping);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute stress XY

Description

Computes the stress from an elastic strain field. compute_total_strain limitations are applicable for stress computation Get the XY shear component (01 component).

Inputs

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Needed to get mesh and material ids. Optional if a data_sources have been connected.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

Needed to get mesh and material ids. Optional if a streams_container have been connected.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10requested
strainname
(fields_container | field)expected type(s)

Field/or fields container containing only the elastic strain field (element nodal).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_stress_XY
  • full name: result.compute_stress_XY
  • internal name: compute_stress_XY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_stress_XY() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.strain.Connect(my_strain)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_stress_XY() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.strain.connect(my_strain)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_stress_XY"); // operator instantiation
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(9, my_requested_location);
op.connect(10, my_strain);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

server: grpc start server

Description

Starts a dpf's grpc server (if local) or connect to one and keep it waiting for requests in a streams.

Inputs

pin 0optional
ipname
(string)expected type(s)

If no ip address is put, the local ip address is taken

pin 1optional
portname
(string | int32)expected type(s)

If no port is put, port 50052 is taken

pin 2optional
starting_optionname
(int32)expected type(s)

default is 1 that starts server in new thread. With 0, this thread will be waiting for grpc calls and will not be usable for anything else. With 2, it the server will be started in a new process.

pin 3optional
should_start_servername
(bool)expected type(s)

If true, the server is assumed to be local and is started. If false, only a client (able to send grpc calls) will be started

pin 4optional
data_sourcesname
(data_sources)expected type(s)

A data source with result key 'grpc' and file path 'port:ip' can be used instead of the input port and IP.

pin 5optional
dpf_contextname
(string | int32)expected type(s)

This pin is associated with pin(2) = 2 (server started in a new process). User can enter the integer associated with a DPF context (1: Standalone Context - DpfCoreStandalone.xml, 3: Custom - DpfCustomDefined.xml) or a string with the path of the XML specifying the context.

Outputs

pin 0optional
grpc_streamsname
(streams_container)expected type(s)

dpf streams handling the server, if the server is started in this thread, then nothing is added in output

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: server
  • plugin: grpc
  • scripting name: grpc_start_server
  • full name: server.grpc_start_server
  • internal name: grpc::stream_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.server.grpc_start_server() # operator instantiation
op.inputs.ip.Connect(my_ip)
op.inputs.port.Connect(my_port)
op.inputs.starting_option.Connect(my_starting_option)
op.inputs.should_start_server.Connect(my_should_start_server)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.dpf_context.Connect(my_dpf_context)
my_grpc_streams = op.outputs.grpc_streams.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.server.grpc_start_server() # operator instantiation
op.inputs.ip.connect(my_ip)
op.inputs.port.connect(my_port)
op.inputs.starting_option.connect(my_starting_option)
op.inputs.should_start_server.connect(my_should_start_server)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.dpf_context.connect(my_dpf_context)
my_grpc_streams = op.outputs.grpc_streams()
#include "dpf_api.h"

ansys::dpf::Operator op("grpc::stream_provider"); // operator instantiation
op.connect(0, my_ip);
op.connect(1, my_port);
op.connect(2, my_starting_option);
op.connect(3, my_should_start_server);
op.connect(4, my_data_sources);
op.connect(5, my_dpf_context);
ansys::dpf::Streams my_grpc_streams = op.getOutput<ansys::dpf::Streams>(0);

utility: operator id

Description

Return the id of an Operator.

Inputs

pin 0requested
opname
(operator)expected type(s)

Outputs

pin 0requested
idname
(int32)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: operator_id
  • full name: utility.operator_id
  • internal name: operator_id
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.operator_id() # operator instantiation
op.inputs.op.Connect(my_op)
my_id = op.outputs.id.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.operator_id() # operator instantiation
op.inputs.op.connect(my_op)
my_id = op.outputs.id()
#include "dpf_api.h"

ansys::dpf::Operator op("operator_id"); // operator instantiation
op.connect(0, my_op);
int my_id = op.getOutput<int>(0);

averaging: elemental nodal to nodal (field)

Description

Transforms an Elemental Nodal field into a Nodal field using an averaging process. The result is computed on a given node's scoping.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
mesh_scopingname
(scoping)expected type(s)

average only on these entities

pin 2optional
should_averagename
(bool)expected type(s)

Each nodal value is divided by the number of elements linked to this node (default is true for discrete quantities).

pin 4optional
extend_to_mid_nodesname
(bool)expected type(s)

Compute mid nodes (when available) by averaging the neighbour primary nodes.

pin 5optional
extend_weights_to_mid_nodesname
(bool)expected type(s)

Extends weights to mid nodes (when available). Default is false.

pin 7optional
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)
pin 1requested
weightname
(property_field)expected type(s)

Provides the number of times it was found in the elemental nodal field, for each node. Can be used to average later.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: elemental_nodal_to_nodal
  • full name: averaging.elemental_nodal_to_nodal
  • internal name: elemental_nodal_To_nodal
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.elemental_nodal_to_nodal() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.should_average.Connect(my_should_average)
op.inputs.extend_to_mid_nodes.Connect(my_extend_to_mid_nodes)
op.inputs.extend_weights_to_mid_nodes.Connect(my_extend_weights_to_mid_nodes)
op.inputs.mesh.Connect(my_mesh)
my_field = op.outputs.field.GetData()
my_weight = op.outputs.weight.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.elemental_nodal_to_nodal() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.should_average.connect(my_should_average)
op.inputs.extend_to_mid_nodes.connect(my_extend_to_mid_nodes)
op.inputs.extend_weights_to_mid_nodes.connect(my_extend_weights_to_mid_nodes)
op.inputs.mesh.connect(my_mesh)
my_field = op.outputs.field()
my_weight = op.outputs.weight()
#include "dpf_api.h"

ansys::dpf::Operator op("elemental_nodal_To_nodal"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_mesh_scoping);
op.connect(2, my_should_average);
op.connect(4, my_extend_to_mid_nodes);
op.connect(5, my_extend_weights_to_mid_nodes);
op.connect(7, my_mesh);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::PropertyField my_weight = op.getOutput<ansys::dpf::PropertyField>(1);

averaging: elemental nodal to nodal (fields container)

Description

Transforms Elemental Nodal fields into Nodal fields using an averaging process. The result is computed on a given node's scoping. If the input fields are mixed shell/solid, then the fields are split by element shape and the output fields container has an elshape label depending on the merge_solid_shell input.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

The mesh region in this pin is used to perform the averaging. It is used if there is no fields support.

pin 2optional
should_averagename
(bool)expected type(s)

Each nodal value is divided by the number of elements linked to this node (default is true for discrete quantities).

pin 3optional
scopingname
(scoping | scopings_container)expected type(s)

Average only on these nodes. If it is a scoping container, the label must correspond to the one of the fields containers.

pin 4optional
extend_to_mid_nodesname
(bool)expected type(s)

Compute mid nodes (when available) by averaging the neighbour primary nodes.

pin 5optional
extend_weights_to_mid_nodesname
(bool)expected type(s)

Extends weights to mid nodes (when available). Default is false.

pin 26optional
merge_solid_shellname
(bool)expected type(s)

For shell/solid mixed fields, group in the same field all solids and shells (false by default). If this pin is true, a shell_layer needs to be specified.

pin 27optional
shell_layername
(int32)expected type(s)

0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid. If merge_solid_shell is true, this pin needs to be specified to a value that extracts only one layer (Top, Bottom or Mid).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
weightsname
(class dataProcessing::DpfTypeCollection)expected type(s)

Gives for each node, the number of times it was found in the Elemental Nodal field. Can be used to average later.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: elemental_nodal_to_nodal_fc
  • full name: averaging.elemental_nodal_to_nodal_fc
  • internal name: elemental_nodal_To_nodal_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.elemental_nodal_to_nodal_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.should_average.Connect(my_should_average)
op.inputs.scoping.Connect(my_scoping)
op.inputs.extend_to_mid_nodes.Connect(my_extend_to_mid_nodes)
op.inputs.extend_weights_to_mid_nodes.Connect(my_extend_weights_to_mid_nodes)
op.inputs.merge_solid_shell.Connect(my_merge_solid_shell)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
my_weights = op.outputs.weights.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.elemental_nodal_to_nodal_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.should_average.connect(my_should_average)
op.inputs.scoping.connect(my_scoping)
op.inputs.extend_to_mid_nodes.connect(my_extend_to_mid_nodes)
op.inputs.extend_weights_to_mid_nodes.connect(my_extend_weights_to_mid_nodes)
op.inputs.merge_solid_shell.connect(my_merge_solid_shell)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
my_weights = op.outputs.weights()
#include "dpf_api.h"

ansys::dpf::Operator op("elemental_nodal_To_nodal_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(2, my_should_average);
op.connect(3, my_scoping);
op.connect(4, my_extend_to_mid_nodes);
op.connect(5, my_extend_weights_to_mid_nodes);
op.connect(26, my_merge_solid_shell);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::Class dataProcessing::DpfTypeCollection my_weights = op.getOutput<ansys::dpf::Class dataProcessing::DpfTypeCollection>(1);

averaging: elemental to nodal (field)

Description

Transforms an Elemental field to a Nodal field. The result is computed on a given node's scoping.

  1. For a finite element mesh, the value on a node is the average of the values of the neighbour elements.

  2. For a volume finite volume mesh, the agorithm is :

    • For each node, compute interpolation weights for the cells connected to it based on the Frink's Laplacian method.
    • If the determinant of the I matrix is zero, switch to an inverse distance weighted average.
    • If not, compute the Frink weights and apply the Holmes' weight clip.
    • If the clipping produces a large overshoot, inverse volume weighted average is used..
  3. For a face finite volume mesh inverse distance weighted average is used.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
mesh_scopingname
(scoping)expected type(s)
pin 2optional
force_averagingname
(int32)expected type(s)

Averaging on nodes is used if this pin is set to 1 (default is 1 for integrated results and 0 for discrete ones).

pin 200optional
algorithmname
(int32)expected type(s)

Forces the usage of algorithm 1, 2 or 3 (default is chosen based on the type of mesh).

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: elemental_to_nodal
  • full name: averaging.elemental_to_nodal
  • internal name: elemental_to_nodal
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.elemental_to_nodal() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.force_averaging.Connect(my_force_averaging)
op.inputs.algorithm.Connect(my_algorithm)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.elemental_to_nodal() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.force_averaging.connect(my_force_averaging)
op.inputs.algorithm.connect(my_algorithm)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("elemental_to_nodal"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_mesh_scoping);
op.connect(2, my_force_averaging);
op.connect(200, my_algorithm);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

averaging: elemental to nodal (fields container)

Description

Transforms Elemental Nodal fields to Nodal fields. The result is computed on a given node's scoping.1. For a finite element mesh, the value on a node is the average of the values of the neighbour elements.

  1. For a finite volume mesh, the agorithm is :
    • For each node, compute interpolation weights for the cells connected to it based on the Frink's Laplacian method.
    • If the determinant of the I matrix is zero, switch to an inverse distance weighted average.
    • If not, compute the Frink weights and apply the Holmes' weight clip.
    • If the clipping produces a large overshoot, inverse volume weighted average is used..
  2. For a face finite volume mesh inverse distance weighted average is used.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)
pin 2optional
force_averagingname
(int32)expected type(s)

Averaging on nodes is used if this pin is set to 1 (default is 1 for integrated results and 0 for discrete ones).

pin 3optional
mesh_scopingname
(scoping | scopings_container)expected type(s)
pin 200optional
algorithmname
(int32)expected type(s)

Forces the usage of algorithm 1, 2 or 3 (default is chosen based on the type of mesh).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: elemental_to_nodal_fc
  • full name: averaging.elemental_to_nodal_fc
  • internal name: elemental_to_nodal_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.elemental_to_nodal_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.force_averaging.Connect(my_force_averaging)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.algorithm.Connect(my_algorithm)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.elemental_to_nodal_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.force_averaging.connect(my_force_averaging)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.algorithm.connect(my_algorithm)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("elemental_to_nodal_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(2, my_force_averaging);
op.connect(3, my_mesh_scoping);
op.connect(200, my_algorithm);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

averaging: to nodal (field)

Description

Transforms a field into a Nodal field using an averaging process. The result is computed on a given node's scoping.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
mesh_scopingname
(scoping)expected type(s)
pin 26optional
merge_solid_shellname
(bool)expected type(s)

For shell/solid mixed fields, group in the same field all solids and shells (false by default). If this pin is true, a shell_layer needs to be specified.

pin 27optional
shell_layername
(int32)expected type(s)

0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid. If merge_solid_shell is true, this pin needs to be specified to a value that extracts only one layer (Top, Bottom or Mid).

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: to_nodal
  • full name: averaging.to_nodal
  • internal name: to_nodal
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.to_nodal() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.merge_solid_shell.Connect(my_merge_solid_shell)
op.inputs.shell_layer.Connect(my_shell_layer)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.to_nodal() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.merge_solid_shell.connect(my_merge_solid_shell)
op.inputs.shell_layer.connect(my_shell_layer)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("to_nodal"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_mesh_scoping);
op.connect(26, my_merge_solid_shell);
op.connect(27, my_shell_layer);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

averaging: to nodal (fields container)

Description

Transforms fields into Nodal fields using an averaging process. The result is computed on a given node's scoping.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
meshname
(abstract_meshed_region)expected type(s)
pin 3optional
mesh_scopingname
(scoping)expected type(s)
pin 26optional
merge_solid_shellname
(bool)expected type(s)

For shell/solid mixed fields, group in the same field all solids and shells (false by default). If this pin is true, a shell_layer needs to be specified.

pin 27optional
shell_layername
(int32)expected type(s)

0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid. If merge_solid_shell is true, this pin needs to be specified to a value that extracts only one layer (Top, Bottom or Mid).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: to_nodal_fc
  • full name: averaging.to_nodal_fc
  • internal name: to_nodal_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.to_nodal_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.merge_solid_shell.Connect(my_merge_solid_shell)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.to_nodal_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.merge_solid_shell.connect(my_merge_solid_shell)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("to_nodal_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(3, my_mesh_scoping);
op.connect(26, my_merge_solid_shell);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

averaging: elemental mean (field)

Description

Computes the average of a multi-entity field, (ElementalNodal -> Elemental), (NodalElemental -> Nodal).

Inputs

pin 0requested
fieldname
(field)expected type(s)
pin 1optional
collapse_shell_layersname
(bool)expected type(s)

If true, shell layers are averaged as well (default is false).

pin 2optional
force_averagingname
(bool)expected type(s)

If true you average, if false you just sum.

pin 3optional
scopingname
(scoping)expected type(s)

Average only on these elements. If it is a scoping container, the label must correspond to the one of the fields containers.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: elemental_mean
  • full name: averaging.elemental_mean
  • internal name: entity_average
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.elemental_mean() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.collapse_shell_layers.Connect(my_collapse_shell_layers)
op.inputs.force_averaging.Connect(my_force_averaging)
op.inputs.scoping.Connect(my_scoping)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.elemental_mean() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.collapse_shell_layers.connect(my_collapse_shell_layers)
op.inputs.force_averaging.connect(my_force_averaging)
op.inputs.scoping.connect(my_scoping)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("entity_average"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_collapse_shell_layers);
op.connect(2, my_force_averaging);
op.connect(3, my_scoping);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

averaging: nodal to elemental (field)

Description

Transforms a Nodal field to an Elemental field, The result is computed on a given element's scoping.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
mesh_scopingname
(scoping)expected type(s)
pin 10optional
collapse_shell_layersname
(bool)expected type(s)

If true, the data across different shell layers is averaged as well (default is false).

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: nodal_to_elemental
  • full name: averaging.nodal_to_elemental
  • internal name: nodal_to_elemental
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.nodal_to_elemental() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.collapse_shell_layers.Connect(my_collapse_shell_layers)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.nodal_to_elemental() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.collapse_shell_layers.connect(my_collapse_shell_layers)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("nodal_to_elemental"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_mesh_scoping);
op.connect(10, my_collapse_shell_layers);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

averaging: nodal to elemental (fields container)

Description

Transforms Nodal fields into Elemental fields using an averaging process. The result is computed on a given element's scoping. If the input fields are mixed shell/solid, and the shell's layers are not specified as collapsed, then the fields are split by element shape and the output fields container has an elshape label.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

The mesh region in this pin is used to perform the averaging. It is used if there is no fields support.

pin 3optional
scopingname
(scoping | scopings_container)expected type(s)

Average only on these elements. If it is a scoping container, the label must correspond to the one of the fields containers.

pin 10optional
collapse_shell_layersname
(bool)expected type(s)

If true, the data across different shell layers is averaged as well (default is false).

pin 26optional
merge_solid_shellname
(bool)expected type(s)

For shell/solid mixed fields, group in the same field all solids and shells (false by default). If this pin is true and collapse_shell_layers is false, a shell_layer needs to be specified.

pin 27optional
shell_layername
(int32)expected type(s)

0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid. If merge_solid_shell is true, this pin needs to be specified to a value that extracts only one layer (Top, Bottom or Mid).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: nodal_to_elemental_fc
  • full name: averaging.nodal_to_elemental_fc
  • internal name: nodal_to_elemental_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.nodal_to_elemental_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.scoping.Connect(my_scoping)
op.inputs.collapse_shell_layers.Connect(my_collapse_shell_layers)
op.inputs.merge_solid_shell.Connect(my_merge_solid_shell)
op.inputs.shell_layer.Connect(my_shell_layer)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.nodal_to_elemental_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.scoping.connect(my_scoping)
op.inputs.collapse_shell_layers.connect(my_collapse_shell_layers)
op.inputs.merge_solid_shell.connect(my_merge_solid_shell)
op.inputs.shell_layer.connect(my_shell_layer)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("nodal_to_elemental_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(3, my_scoping);
op.connect(10, my_collapse_shell_layers);
op.connect(26, my_merge_solid_shell);
op.connect(27, my_shell_layer);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

averaging: nodal to elemental nodal (field)

Description

Transforms a Nodal field to an ElementalNodal field, The result is computed on a given element's scoping.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
mesh_scopingname
(scoping)expected type(s)
pin 10optional
collapse_shell_layersname
(bool)expected type(s)

If true, the data across different shell layers is averaged as well (default is false).

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: nodal_to_elemental_nodal
  • full name: averaging.nodal_to_elemental_nodal
  • internal name: nodal_to_elemental_nodal
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.nodal_to_elemental_nodal() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.collapse_shell_layers.Connect(my_collapse_shell_layers)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.nodal_to_elemental_nodal() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.collapse_shell_layers.connect(my_collapse_shell_layers)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("nodal_to_elemental_nodal"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_mesh_scoping);
op.connect(10, my_collapse_shell_layers);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

averaging: nodal to elemental nodal (fields container)

Description

Transforms Nodal fields_container to Elemental Nodal fields_container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
meshname
(abstract_meshed_region)expected type(s)
pin 3optional
mesh_scopingname
(scoping)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: nodal_to_elemental_nodal_fc
  • full name: averaging.nodal_to_elemental_nodal_fc
  • internal name: nodal_to_elemental_nodal_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.nodal_to_elemental_nodal_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.nodal_to_elemental_nodal_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("nodal_to_elemental_nodal_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(3, my_mesh_scoping);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

invariant: eigen values (field)

Description

Computes the element-wise Eigen values of a tensor field.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: invariant
  • plugin: core
  • scripting name: eigen_values
  • full name: invariant.eigen_values
  • internal name: eig_values
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.eigen_values() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.eigen_values() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("eig_values"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

invariant: principal invariants (field)

Description

Computes the element-wise Eigen values of a tensor field.

Inputs

pin 0requested
fieldname
(field)expected type(s)

Outputs

pin 0requested
field_eig_1name
(field)expected type(s)

first eigen value field

pin 1requested
field_eig_2name
(field)expected type(s)

second eigen value field

pin 2requested
field_eig_3name
(field)expected type(s)

third eigen value field

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: invariant
  • plugin: core
  • scripting name: principal_invariants
  • full name: invariant.principal_invariants
  • internal name: invariants
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.principal_invariants() # operator instantiation
op.inputs.field.Connect(my_field)
my_field_eig_1 = op.outputs.field_eig_1.GetData()
my_field_eig_2 = op.outputs.field_eig_2.GetData()
my_field_eig_3 = op.outputs.field_eig_3.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.principal_invariants() # operator instantiation
op.inputs.field.connect(my_field)
my_field_eig_1 = op.outputs.field_eig_1()
my_field_eig_2 = op.outputs.field_eig_2()
my_field_eig_3 = op.outputs.field_eig_3()
#include "dpf_api.h"

ansys::dpf::Operator op("invariants"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field_eig_1 = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_field_eig_2 = op.getOutput<ansys::dpf::Field>(1);
ansys::dpf::Field my_field_eig_3 = op.getOutput<ansys::dpf::Field>(2);

invariant: von mises eqv (fields container)

Description

Computes the element-wise Von-Mises criteria on all the tensor fields of a fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 13requested
poisson_rationame
(double | int32)expected type(s)

Poisson ratio to be used in equivalent strain calculation.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: invariant
  • plugin: core
  • scripting name: von_mises_eqv_fc
  • full name: invariant.von_mises_eqv_fc
  • internal name: eqv_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.von_mises_eqv_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.poisson_ratio.Connect(my_poisson_ratio)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.von_mises_eqv_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.poisson_ratio.connect(my_poisson_ratio)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("eqv_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(13, my_poisson_ratio);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

invariant: segalman von mises eqv (fields container)

Description

Computes the element-wise Segalman Von-Mises criteria on all the tensor fields of a fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: invariant
  • plugin: core
  • scripting name: segalman_von_mises_eqv_fc
  • full name: invariant.segalman_von_mises_eqv_fc
  • internal name: segalmaneqv_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.segalman_von_mises_eqv_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.segalman_von_mises_eqv_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("segalmaneqv_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

scoping: compute element centroids

Description

Computes the element centroids of the mesh. It also outputs the element measure.

Inputs

pin 1optional
element_scopingname
(scoping)expected type(s)

If provided, only the centroids of the elements in the scoping are computed.

pin 7requested
meshname
(abstract_meshed_region)expected type(s)

Mesh to compute centroids

Outputs

pin 0requested
centroidsname
(field)expected type(s)

element centroids.

pin 1requested
measurename
(field)expected type(s)

element measure (length, surface or volume depending on the dimension of the element).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: scoping
  • plugin: core
  • scripting name: compute_element_centroids
  • full name: scoping.compute_element_centroids
  • internal name: compute_element_centroids
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.scoping.compute_element_centroids() # operator instantiation
op.inputs.element_scoping.Connect(my_element_scoping)
op.inputs.mesh.Connect(my_mesh)
my_centroids = op.outputs.centroids.GetData()
my_measure = op.outputs.measure.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.scoping.compute_element_centroids() # operator instantiation
op.inputs.element_scoping.connect(my_element_scoping)
op.inputs.mesh.connect(my_mesh)
my_centroids = op.outputs.centroids()
my_measure = op.outputs.measure()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_element_centroids"); // operator instantiation
op.connect(1, my_element_scoping);
op.connect(7, my_mesh);
ansys::dpf::Field my_centroids = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_measure = op.getOutput<ansys::dpf::Field>(1);

math: entity extractor

Description

Extracts an entity from a field, based on its ID.

Inputs

pin 0requested
fieldAname
(field)expected type(s)
pin 1requested
scalar_intname
(int32)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: entity_extractor
  • full name: math.entity_extractor
  • internal name: entity_extractor
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.entity_extractor() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.scalar_int.Connect(my_scalar_int)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.entity_extractor() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.scalar_int.connect(my_scalar_int)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("entity_extractor"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_scalar_int);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

metadata: cyclic mesh expansion

Description

Expand the mesh.

Inputs

pin 7optional
sector_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)
pin 16requested
cyclic_support (modified inplace)name
(cyclic_support)expected type(s)
pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label.

Outputs

pin 0requested
meshed_regionname
(abstract_meshed_region)expected type(s)

expanded meshed region.

pin 1requested
cyclic_supportname
(cyclic_support)expected type(s)

input cyclic support modified in place containing the new expanded meshed regions.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: metadata
  • plugin: core
  • scripting name: cyclic_mesh_expansion
  • full name: metadata.cyclic_mesh_expansion
  • internal name: cyclic_expansion_mesh
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.metadata.cyclic_mesh_expansion() # operator instantiation
op.inputs.sector_meshed_region.Connect(my_sector_meshed_region)
op.inputs.cyclic_support (modified inplace).Connect(my_cyclic_support (modified inplace))
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
my_meshed_region = op.outputs.meshed_region.GetData()
my_cyclic_support = op.outputs.cyclic_support.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.metadata.cyclic_mesh_expansion() # operator instantiation
op.inputs.sector_meshed_region.connect(my_sector_meshed_region)
op.inputs.cyclic_support (modified inplace).connect(my_cyclic_support (modified inplace))
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
my_meshed_region = op.outputs.meshed_region()
my_cyclic_support = op.outputs.cyclic_support()
#include "dpf_api.h"

ansys::dpf::Operator op("cyclic_expansion_mesh"); // operator instantiation
op.connect(7, my_sector_meshed_region);
op.connect(16, my_cyclic_support (modified inplace));
op.connect(18, my_sectors_to_expand);
ansys::dpf::MeshedRegion my_meshed_region = op.getOutput<ansys::dpf::MeshedRegion>(0);
ansys::dpf::CyclicSupport my_cyclic_support = op.getOutput<ansys::dpf::CyclicSupport>(1);

result: remove rigid body motion (fields container)

Description

Removes rigid body mode from a total displacement field by minimization. Use a reference point in order to subtract its displacement to the result displacement field.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
reference_node_idname
(int32)expected type(s)

Id of the reference entity (node).

pin 7optional
meshname
(abstract_meshed_region)expected type(s)

default is the mesh in the support

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
translation_fieldname
(field)expected type(s)

Global rigid translation vector

pin 2requested
rotation_fieldname
(field)expected type(s)

Global rigid rotation angles

pin 3requested
center_fieldname
(field)expected type(s)

Center of the rigid rotation

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: remove_rigid_body_motion_fc
  • full name: result.remove_rigid_body_motion_fc
  • internal name: ExtractRigidBodyMotion_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.remove_rigid_body_motion_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.reference_node_id.Connect(my_reference_node_id)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
my_translation_field = op.outputs.translation_field.GetData()
my_rotation_field = op.outputs.rotation_field.GetData()
my_center_field = op.outputs.center_field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.remove_rigid_body_motion_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.reference_node_id.connect(my_reference_node_id)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
my_translation_field = op.outputs.translation_field()
my_rotation_field = op.outputs.rotation_field()
my_center_field = op.outputs.center_field()
#include "dpf_api.h"

ansys::dpf::Operator op("ExtractRigidBodyMotion_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_reference_node_id);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::Field my_translation_field = op.getOutput<ansys::dpf::Field>(1);
ansys::dpf::Field my_rotation_field = op.getOutput<ansys::dpf::Field>(2);
ansys::dpf::Field my_center_field = op.getOutput<ansys::dpf::Field>(3);

result: cyclic analytic stress eqv max

Description

Compute the maximum of the Von Mises equivalent stress that can be expected on 360 degrees

Inputs

pin 0optional
time_scopingname
(scoping | vector)expected type(s)
pin 1optional
mesh_scopingname
(scopings_container | scoping | vector)expected type(s)
pin 2requested
fields_containername
(fields_container)expected type(s)

field container with the base and duplicate sectors

pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

default is true

pin 16requested
cyclic_supportname
(cyclic_support)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

FieldsContainer filled in

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.

Scripting

  • category: result
  • plugin: core
  • scripting name: cyclic_analytic_seqv_max
  • full name: result.cyclic_analytic_seqv_max
  • internal name: cyclic_analytic_stress_eqv_max
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.cyclic_analytic_seqv_max() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.cyclic_support.Connect(my_cyclic_support)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.cyclic_analytic_seqv_max() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container.connect(my_fields_container)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.cyclic_support.connect(my_cyclic_support)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("cyclic_analytic_stress_eqv_max"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container);
op.connect(5, my_bool_rotate_to_global);
op.connect(16, my_cyclic_support);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

averaging: nodal fraction (fields container)

Description

Transforms Elemental Nodal fields into Nodal fields. Each nodal value is the fraction between the nodal difference and the nodal average. The result is computed on a given node's scoping.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
meshname
(abstract_meshed_region)expected type(s)

The mesh region in this pin is used to perform the averaging. It is used if there is no fields support.

pin 3optional
scopingname
(scoping)expected type(s)

Average only on these nodes. If it is a scoping container, the label must correspond to the one of the fields containers.

pin 6optional
denominatorname
(fields_container)expected type(s)

If a fields container is set in this pin, it is used as the denominator of the fraction instead of elemental_nodal_To_nodal_fc.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: nodal_fraction_fc
  • full name: averaging.nodal_fraction_fc
  • internal name: nodal_fraction_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.nodal_fraction_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.scoping.Connect(my_scoping)
op.inputs.denominator.Connect(my_denominator)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.nodal_fraction_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.scoping.connect(my_scoping)
op.inputs.denominator.connect(my_denominator)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("nodal_fraction_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(3, my_scoping);
op.connect(6, my_denominator);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: cyclic expansion

Description

Expand cyclic results from a fieldsContainer for given sets, sectors and scoping (optionals).

Inputs

pin 0optional
time_scopingname
(scoping | vector)expected type(s)
pin 1optional
mesh_scopingname
(scopings_container | scoping | vector)expected type(s)
pin 2requested
fields_containername
(fields_container)expected type(s)

field container with the base and duplicate sectors

pin 3optional
harmonic_indexname
(int32)expected type(s)
pin 5optional
bool_rotate_to_globalname
(bool)expected type(s)

default is true

pin 6optional
map_size_scoping_outname
(umap)expected type(s)

map provider by scoping adapter

pin 7optional
normalization_factorname
(double)expected type(s)
pin 14optional
merge_stagesname
(bool)expected type(s)
pin 16requested
cyclic_supportname
(cyclic_support)expected type(s)
pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

FieldsContainer filled in

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.

Scripting

  • category: result
  • plugin: core
  • scripting name: cyclic_expansion
  • full name: result.cyclic_expansion
  • internal name: cyclic_expansion
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.cyclic_expansion() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.harmonic_index.Connect(my_harmonic_index)
op.inputs.bool_rotate_to_global.Connect(my_bool_rotate_to_global)
op.inputs.map_size_scoping_out.Connect(my_map_size_scoping_out)
op.inputs.normalization_factor.Connect(my_normalization_factor)
op.inputs.merge_stages.Connect(my_merge_stages)
op.inputs.cyclic_support.Connect(my_cyclic_support)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.cyclic_expansion() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container.connect(my_fields_container)
op.inputs.harmonic_index.connect(my_harmonic_index)
op.inputs.bool_rotate_to_global.connect(my_bool_rotate_to_global)
op.inputs.map_size_scoping_out.connect(my_map_size_scoping_out)
op.inputs.normalization_factor.connect(my_normalization_factor)
op.inputs.merge_stages.connect(my_merge_stages)
op.inputs.cyclic_support.connect(my_cyclic_support)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("cyclic_expansion"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container);
op.connect(3, my_harmonic_index);
op.connect(5, my_bool_rotate_to_global);
op.connect(6, my_map_size_scoping_out);
op.connect(7, my_normalization_factor);
op.connect(14, my_merge_stages);
op.connect(16, my_cyclic_support);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: recombine cyclic harmonic indices

Description

Add the fields corresponding to different load steps with the same frequencies to compute the response.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cacheSome intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
(bool)expected type(s)
truedefault value
: Some intermediate data is put in cache if this config is set to true. This option can reduce computation time after the first run.
work_by_indexIf this option is set to true, loops and comparisons by entity will be done by index instead of ids.
(bool)expected type(s)
falsedefault value
: If this option is set to true, loops and comparisons by entity will be done by index instead of ids.

Scripting

  • category: result
  • plugin: core
  • scripting name: recombine_harmonic_indeces_cyclic
  • full name: result.recombine_harmonic_indeces_cyclic
  • internal name: recombine_harmonic_indeces_cyclic
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.recombine_harmonic_indeces_cyclic() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.recombine_harmonic_indeces_cyclic() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("recombine_harmonic_indeces_cyclic"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

mapping: on coordinates

Description

Evaluates a result on specified coordinates (interpolates results inside elements with shape functions).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
coordinatesname
(field | fields_container | abstract_meshed_region | meshes_container)expected type(s)
pin 2optional
create_supportname
(bool)expected type(s)

if this pin is set to true, then, a support associated to the fields consisting of points is created

pin 3optional
mapping_on_scopingname
(bool)expected type(s)

if this pin is set to true, then the mapping between the coordinates and the fields is created only on the first field scoping

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

if the first field in input has no mesh in support, then the mesh in this pin is expected (default is false), if a meshes container with several meshes is set, it should be on the same label spaces as the coordinates fields container

pin 200optional
use_quadratic_elementsname
(bool)expected type(s)

If this pin is set to true, the element search for each coordinate is computed on the quadratic element if the element is quadratic (more precise but less performant). Default is false.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mapping
  • plugin: core
  • scripting name: on_coordinates
  • full name: mapping.on_coordinates
  • internal name: mapping
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mapping.on_coordinates() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.coordinates.Connect(my_coordinates)
op.inputs.create_support.Connect(my_create_support)
op.inputs.mapping_on_scoping.Connect(my_mapping_on_scoping)
op.inputs.mesh.Connect(my_mesh)
op.inputs.use_quadratic_elements.Connect(my_use_quadratic_elements)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mapping.on_coordinates() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.coordinates.connect(my_coordinates)
op.inputs.create_support.connect(my_create_support)
op.inputs.mapping_on_scoping.connect(my_mapping_on_scoping)
op.inputs.mesh.connect(my_mesh)
op.inputs.use_quadratic_elements.connect(my_use_quadratic_elements)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("mapping"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_coordinates);
op.connect(2, my_create_support);
op.connect(3, my_mapping_on_scoping);
op.connect(7, my_mesh);
op.connect(200, my_use_quadratic_elements);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

mapping: scoping on coordinates

Description

Finds the Elemental scoping of a set of coordinates.

Inputs

pin 0requested
coordinatesname
(field)expected type(s)
pin 7requested
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mapping
  • plugin: core
  • scripting name: scoping_on_coordinates
  • full name: mapping.scoping_on_coordinates
  • internal name: scoping::on_coordinates
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mapping.scoping_on_coordinates() # operator instantiation
op.inputs.coordinates.Connect(my_coordinates)
op.inputs.mesh.Connect(my_mesh)
my_scoping = op.outputs.scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mapping.scoping_on_coordinates() # operator instantiation
op.inputs.coordinates.connect(my_coordinates)
op.inputs.mesh.connect(my_mesh)
my_scoping = op.outputs.scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("scoping::on_coordinates"); // operator instantiation
op.connect(0, my_coordinates);
op.connect(7, my_mesh);
ansys::dpf::Scoping my_scoping = op.getOutput<ansys::dpf::Scoping>(0);

filter: abc weightings

Description

Computes ABC-weightings for the amplitude spectrum in dB units.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

data to be weighted in dB units.

pin 1requested
weighting_typename
(int32)expected type(s)

if this pin is set to 0, the A-weighting is computed, 1 the B-weigting is computed and 2 the C-weightings is computed.

pin 2requested
shape_by_tf_scopingname
(bool)expected type(s)

if this pin is set to true, each field of the input fields container is defined by time freq scoping and not by ids. Default is false

Outputs

pin 0requested
weightingsname
(fields_container)expected type(s)

weighted data in dB units.

Configurations

inplaceThe output is written over the input to save memory if this config is set to true.
(bool)expected type(s)
falsedefault value
: The output is written over the input to save memory if this config is set to true.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: filter
  • plugin: core
  • scripting name: abc_weightings
  • full name: filter.abc_weightings
  • internal name: abc_weightings
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.filter.abc_weightings() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.weighting_type.Connect(my_weighting_type)
op.inputs.shape_by_tf_scoping.Connect(my_shape_by_tf_scoping)
my_weightings = op.outputs.weightings.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.filter.abc_weightings() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.weighting_type.connect(my_weighting_type)
op.inputs.shape_by_tf_scoping.connect(my_shape_by_tf_scoping)
my_weightings = op.outputs.weightings()
#include "dpf_api.h"

ansys::dpf::Operator op("abc_weightings"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_weighting_type);
op.connect(2, my_shape_by_tf_scoping);
ansys::dpf::FieldsContainer my_weightings = op.getOutput<ansys::dpf::FieldsContainer>(0);

mapping: solid to skin

Description

Maps a field defined on solid elements to a field defined on skin elements. Three cases are possible, based on the solid field data location; (i) Elemental: The values associated with the solid elements are copied according to those underlying the skin, (ii) Nodal: The solid field is rescoped with respect to the nodes of the skin mesh, (iii) ElementalNodal: The values are copied from the solid mesh to the skin mesh for each element face and the nodes associated with it.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
meshname
(abstract_meshed_region)expected type(s)

skin mesh region expected

pin 2optional
solid_meshname
(abstract_meshed_region)expected type(s)

Solid mesh support (optional).

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mapping
  • plugin: core
  • scripting name: solid_to_skin
  • full name: mapping.solid_to_skin
  • internal name: solid_to_skin
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mapping.solid_to_skin() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.mesh.Connect(my_mesh)
op.inputs.solid_mesh.Connect(my_solid_mesh)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mapping.solid_to_skin() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.mesh.connect(my_mesh)
op.inputs.solid_mesh.connect(my_solid_mesh)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("solid_to_skin"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_mesh);
op.connect(2, my_solid_mesh);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

mapping: solid to skin (fields container)

Description

Maps a field defined on solid elements to a field defined on skin elements. Three cases are possible, based on the solid field data location; (i) Elemental: The values associated with the solid elements are copied according to those underlying the skin, (ii) Nodal: The solid field is rescoped with respect to the nodes of the skin mesh, (iii) ElementalNodal: The values are copied from the solid mesh to the skin mesh for each element face and the nodes associated with it.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

field or fields container with only one field is expected

pin 1requested
meshname
(abstract_meshed_region)expected type(s)

skin mesh region expected

pin 2optional
solid_meshname
(abstract_meshed_region)expected type(s)

Solid mesh support (optional).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mapping
  • plugin: core
  • scripting name: solid_to_skin_fc
  • full name: mapping.solid_to_skin_fc
  • internal name: solid_to_skin_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mapping.solid_to_skin_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.solid_mesh.Connect(my_solid_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mapping.solid_to_skin_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.solid_mesh.connect(my_solid_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("solid_to_skin_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(2, my_solid_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

averaging: elemental difference (field)

Description

Transforms an Elemental Nodal or Nodal field into an Elemental field. Each elemental value is the maximum difference between the computed result for all nodes in this element. The result is computed on a given element scoping.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
mesh_scopingname
(scoping)expected type(s)

average only on these entities

pin 7optional
meshname
(abstract_meshed_region)expected type(s)
pin 10optional
through_layersname
(bool)expected type(s)

The maximum elemental difference is taken through the different shell layers if true (default is false).

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: elemental_difference
  • full name: averaging.elemental_difference
  • internal name: elemental_difference
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.elemental_difference() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.mesh.Connect(my_mesh)
op.inputs.through_layers.Connect(my_through_layers)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.elemental_difference() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.mesh.connect(my_mesh)
op.inputs.through_layers.connect(my_through_layers)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("elemental_difference"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_mesh_scoping);
op.connect(7, my_mesh);
op.connect(10, my_through_layers);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

averaging: elemental fraction (fields container)

Description

Transforms Elemental Nodal fields into Elemental fields. Each elemental value is the fraction between the elemental difference and the entity average. The result is computed on a given element's scoping.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
meshname
(abstract_meshed_region)expected type(s)

The mesh region in this pin is used to perform the averaging. It is used if there is no fields support.

pin 3optional
scopingname
(scoping)expected type(s)

Average only on these elements. If it is a scoping container, the label must correspond to the one of the fields containers.

pin 6optional
denominatorname
(fields_container)expected type(s)

If a fields container is set in this pin, it is used as the denominator of the fraction instead of entity_average_fc.

pin 10optional
collapse_shell_layersname
(bool)expected type(s)

If true, the data across different shell layers is averaged as well (default is false).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: elemental_fraction_fc
  • full name: averaging.elemental_fraction_fc
  • internal name: elemental_fraction_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.elemental_fraction_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.scoping.Connect(my_scoping)
op.inputs.denominator.Connect(my_denominator)
op.inputs.collapse_shell_layers.Connect(my_collapse_shell_layers)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.elemental_fraction_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.scoping.connect(my_scoping)
op.inputs.denominator.connect(my_denominator)
op.inputs.collapse_shell_layers.connect(my_collapse_shell_layers)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("elemental_fraction_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(3, my_scoping);
op.connect(6, my_denominator);
op.connect(10, my_collapse_shell_layers);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

averaging: extend to mid nodes (fields container)

Description

Extends Elemental Nodal or Nodal fields defined on corner nodes to Elemental Nodal fields defined also on the mid nodes.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
meshname
(abstract_meshed_region)expected type(s)

The mesh region in this pin is used to perform the averaging. It is used if there is no fields support.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

inplaceThe output is written over the input to save memory if this configuration is set to true. Only supported for nodal fields in input.
(bool)expected type(s)
falsedefault value
: The output is written over the input to save memory if this configuration is set to true. Only supported for nodal fields in input.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: extend_to_mid_nodes_fc
  • full name: averaging.extend_to_mid_nodes_fc
  • internal name: extend_to_mid_nodes_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.extend_to_mid_nodes_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.extend_to_mid_nodes_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("extend_to_mid_nodes_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

geo: rotate cylindrical coordinates

Description

Rotates a field to its corresponding values into the specified cylindrical coordinate system (corresponding to the field position). If a coordinate system is not set in the coordinate_system pin, the field is rotated on each node following the local polar coordinate system.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
coordinate_systemname
(field)expected type(s)

3-3 rotation matrix and origin coordinates must be set here to define a coordinate system.

pin 2optional
meshname
(abstract_meshed_region)expected type(s)

Mesh support of the input field.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: geo
  • plugin: core
  • scripting name: rotate_in_cylindrical_cs
  • full name: geo.rotate_in_cylindrical_cs
  • internal name: transform_cylindricalCS
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.rotate_in_cylindrical_cs() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.coordinate_system.Connect(my_coordinate_system)
op.inputs.mesh.Connect(my_mesh)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.rotate_in_cylindrical_cs() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.coordinate_system.connect(my_coordinate_system)
op.inputs.mesh.connect(my_mesh)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("transform_cylindricalCS"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_coordinate_system);
op.connect(2, my_mesh);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

geo: rotate in cylindrical coordinates (fields container)

Description

Rotates all the fields of a fields container (not defined with a cynlindrical coordinate system) to its corresponding values into the specified cylindrical coordinate system (corresponding to the field position). If a coordinate system is not set in the coordinate_system pin, the field is rotated on each node following the local polar coordinate system.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)
pin 1optional
coordinate_systemname
(field)expected type(s)

3-3 rotation matrix and origin coordinates must be set here to define a coordinate system.

pin 2optional
meshname
(abstract_meshed_region)expected type(s)

Mesh support of the input fields_container, in case it does not have one defined.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: geo
  • plugin: core
  • scripting name: rotate_in_cylindrical_cs_fc
  • full name: geo.rotate_in_cylindrical_cs_fc
  • internal name: transform_cylindrical_cs_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.rotate_in_cylindrical_cs_fc() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.coordinate_system.Connect(my_coordinate_system)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.rotate_in_cylindrical_cs_fc() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.coordinate_system.connect(my_coordinate_system)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("transform_cylindrical_cs_fc"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_coordinate_system);
op.connect(2, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

geo: spherical to cartesian coordinates (fields container)

Description

Converts 3D field from spherical coordinates to cartesian coordinates.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: geo
  • plugin: core
  • scripting name: spherical_to_cartesian_fc
  • full name: geo.spherical_to_cartesian_fc
  • internal name: spherical_to_cartesian_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.spherical_to_cartesian_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.spherical_to_cartesian_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("spherical_to_cartesian_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

geo: spherical to cartesian coordinates

Description

Converts 3D field from spherical coordinates to cartesian coordinates.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: geo
  • plugin: core
  • scripting name: spherical_to_cartesian
  • full name: geo.spherical_to_cartesian
  • internal name: spherical_to_cartesian
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.spherical_to_cartesian() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.spherical_to_cartesian() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("spherical_to_cartesian"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

mesh: change cs (meshes)

Description

Applies a transformation (rotation and displacement) matrix on a mesh or meshes container.

Inputs

pin 0requested
meshesname
(meshed_region | meshes_container)expected type(s)
pin 1requested
coordinate_systemname
(field)expected type(s)

3-3 rotation matrix + 3 translations (X, Y, Z)

Outputs

pin 0requested
meshed_regionname
(meshed_region | meshes_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: change_cs
  • full name: mesh.change_cs
  • internal name: mesh::change_cs
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.change_cs() # operator instantiation
op.inputs.meshes.Connect(my_meshes)
op.inputs.coordinate_system.Connect(my_coordinate_system)
my_meshed_region = op.outputs.meshed_region.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.change_cs() # operator instantiation
op.inputs.meshes.connect(my_meshes)
op.inputs.coordinate_system.connect(my_coordinate_system)
my_meshed_region = op.outputs.meshed_region()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh::change_cs"); // operator instantiation
op.connect(0, my_meshes);
op.connect(1, my_coordinate_system);
ansys::dpf::MeshedRegion my_meshed_region = op.getOutput<ansys::dpf::MeshedRegion>(0);

geo: normals provider nl (nodes, faces, or elements)

Description

Computes the normals on nodes/faces/elements based on integration points (more accurate for non-linear elements) on a skin mesh.

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)

Skin, face, or shell mesh region.

pin 1optional
mesh_scopingname
(scoping)expected type(s)

Elemental, ElementalNodal, or Nodal scoping. Location derived from this.

pin 9optional
requested_locationname
(string)expected type(s)

If no scoping, specifies location. If scoping is Elemental or ElementalNodal this overrides scoping. Default is Elemental.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: geo
  • plugin: core
  • scripting name: normals_provider_nl
  • full name: geo.normals_provider_nl
  • internal name: normals_provider_nl
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.normals_provider_nl() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.requested_location.Connect(my_requested_location)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.normals_provider_nl() # operator instantiation
op.inputs.mesh.connect(my_mesh)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.requested_location.connect(my_requested_location)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("normals_provider_nl"); // operator instantiation
op.connect(0, my_mesh);
op.connect(1, my_mesh_scoping);
op.connect(9, my_requested_location);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

geo: elements volumes over time

Description

Calculates for a mesh, the volume of each element over time for each specified time step.

Inputs

pin 1optional
scopingname
(scoping)expected type(s)
pin 2optional
displacementname
(fields_container)expected type(s)

Displacement field's container. Must contain the mesh if mesh not specified in input.

pin 7optional
meshname
(abstract_meshed_region)expected type(s)

Mesh must be defined if the displacement field's container does not contain it, or if there is no displacement.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: geo
  • plugin: core
  • scripting name: elements_volumes_over_time
  • full name: geo.elements_volumes_over_time
  • internal name: volumes_provider
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.elements_volumes_over_time() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.displacement.Connect(my_displacement)
op.inputs.mesh.Connect(my_mesh)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.elements_volumes_over_time() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.displacement.connect(my_displacement)
op.inputs.mesh.connect(my_mesh)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("volumes_provider"); // operator instantiation
op.connect(1, my_scoping);
op.connect(2, my_displacement);
op.connect(7, my_mesh);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: window bartlett

Description

Apply bartlett windowing on a given FieldsContainer having time label or a Field located on time. Assume that time sampling is evenly spaced (use time_freq_interpolation before otherwise).

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Outputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: window_bartlett
  • full name: math.window_bartlett
  • internal name: window::bartlett
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.window_bartlett() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.window_bartlett() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("window::bartlett"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

mesh: from scoping

Description

Extracts a meshed region from another meshed region based on a scoping. Regarding the property fields of the meshed region: the 'Elemental', 'Face', and 'Nodal' property fields are scoped to the elements, faces or nodes of the output mesh, the 'Global' property fields are transferred from the input mesh to the output mesh without changes, and the rest of the property fields are not present in the output mesh.

Inputs

pin 1requested
scopingname
(scoping)expected type(s)

if nodal/face scoping, then the scoping is transposed respecting the inclusive pin

pin 2optional
inclusivename
(int32)expected type(s)

if inclusive == 1 then all the elements/faces adjacent to the nodes/faces ids in input are added, if inclusive == 0, only the elements/faces which have all their nodes/faces in the scoping are included

pin 3optional
nodes_onlyname
(bool)expected type(s)

returns mesh with nodes only (without any elements or property fields). Default is false.

pin 7requested
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: from_scoping
  • full name: mesh.from_scoping
  • internal name: mesh::by_scoping
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.from_scoping() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.inclusive.Connect(my_inclusive)
op.inputs.nodes_only.Connect(my_nodes_only)
op.inputs.mesh.Connect(my_mesh)
my_mesh = op.outputs.mesh.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.from_scoping() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.inclusive.connect(my_inclusive)
op.inputs.nodes_only.connect(my_nodes_only)
op.inputs.mesh.connect(my_mesh)
my_mesh = op.outputs.mesh()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh::by_scoping"); // operator instantiation
op.connect(1, my_scoping);
op.connect(2, my_inclusive);
op.connect(3, my_nodes_only);
op.connect(7, my_mesh);
ansys::dpf::MeshedRegion my_mesh = op.getOutput<ansys::dpf::MeshedRegion>(0);

mesh: split field wrt mesh regions

Description

Split the input field or fields container based on the input mesh regions

Inputs

pin 0requested
field_or_fields_containername
(field | fields_container)expected type(s)
pin 1requested
meshesname
(meshes_container)expected type(s)

body meshes in the mesh controller cannot be mixed shell/solid

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: split_fields
  • full name: mesh.split_fields
  • internal name: split_fields
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.split_fields() # operator instantiation
op.inputs.field_or_fields_container.Connect(my_field_or_fields_container)
op.inputs.meshes.Connect(my_meshes)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.split_fields() # operator instantiation
op.inputs.field_or_fields_container.connect(my_field_or_fields_container)
op.inputs.meshes.connect(my_meshes)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("split_fields"); // operator instantiation
op.connect(0, my_field_or_fields_container);
op.connect(1, my_meshes);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: torque

Description

Compute torque of a force based on a 3D point.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

fields_container

pin 1requested
fieldname
(field)expected type(s)

field

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: torque
  • full name: result.torque
  • internal name: torque
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.torque() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.field.Connect(my_field)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.torque() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.field.connect(my_field)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("torque"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_field);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

averaging: force_summation_psd

Description

Computes the sum of elemental forces contribution on a set of nodes in Global Coordinate System for a PSD analysis. Equivalent to MAPDL FSUM/NFORCE.

Inputs

pin 1optional
nodal_scopingname
(scoping)expected type(s)

Nodal Scoping. Set of nodes in which elemental contribution forces will be accumulated. Defaults to all nodes.

pin 2optional
elemental_scopingname
(scoping)expected type(s)

Elemental Scoping. Set of elements contributing to the force calculation. Defaults to all elements.

pin 3optional
streamsname
(streams_container)expected type(s)

Streams container for RST and PSD files (optional if using data sources). The operator supports both a single RST file and two separate RST files. See data sources pin specifications for details on how to define the streams for both cases.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Data sources containing RST and PSD files (optional if using a streams container). The operator supports both a single RST file (containing both modal and PSD results) and two separate RST files (one for modal and one for PSD analyses).The data source containing modal results must be defined as an upstream data source.If using a single RST file for PSD and modal analysis, the RST file must be in an upstream data source.If using two separate RST files, only the modal RST must be in an upstream data source.

pin 6optional
spointname
(field)expected type(s)

Coordinate field of a point for moment summations. Defaults to (0,0,0).

pin 7optional
abs_rel_keyname
(field)expected type(s)

Key to select the type of response: 0 for relative response (default) or 1 for absolute response.

pin 8optional
signifname
(double)expected type(s)

Significance threshold, defaults to 0.0001. Any mode with a significance level above this value will be included in the combination.The significance level is defined as the modal covariance matrix term, divided by the maximum modal covariance matrix term.

Outputs

pin 0requested
force_accumulationname
(fields_container)expected type(s)

Returns the sum of forces for the 1-sigma displacement solution on the scoped nodes/elements.

pin 1requested
moment_accumulationname
(fields_container)expected type(s)

Returns the sum of moments for the 1-sigma displacement solution on the scoped nodes/elements.

pin 10requested
forces_on_nodesname
(fields_container)expected type(s)

Returns the nodal forces for the 1-sigma displacement solution on the scoped nodes/elements.

pin 11requested
moments_on_nodesname
(fields_container)expected type(s)

Returns the nodal moments for the 1-sigma displacement solution on the scoped nodes/elements.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: force_summation_psd
  • full name: averaging.force_summation_psd
  • internal name: force_summation_psd
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.force_summation_psd() # operator instantiation
op.inputs.nodal_scoping.Connect(my_nodal_scoping)
op.inputs.elemental_scoping.Connect(my_elemental_scoping)
op.inputs.streams.Connect(my_streams)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.spoint.Connect(my_spoint)
op.inputs.abs_rel_key.Connect(my_abs_rel_key)
op.inputs.signif.Connect(my_signif)
my_force_accumulation = op.outputs.force_accumulation.GetData()
my_moment_accumulation = op.outputs.moment_accumulation.GetData()
my_forces_on_nodes = op.outputs.forces_on_nodes.GetData()
my_moments_on_nodes = op.outputs.moments_on_nodes.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.force_summation_psd() # operator instantiation
op.inputs.nodal_scoping.connect(my_nodal_scoping)
op.inputs.elemental_scoping.connect(my_elemental_scoping)
op.inputs.streams.connect(my_streams)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.spoint.connect(my_spoint)
op.inputs.abs_rel_key.connect(my_abs_rel_key)
op.inputs.signif.connect(my_signif)
my_force_accumulation = op.outputs.force_accumulation()
my_moment_accumulation = op.outputs.moment_accumulation()
my_forces_on_nodes = op.outputs.forces_on_nodes()
my_moments_on_nodes = op.outputs.moments_on_nodes()
#include "dpf_api.h"

ansys::dpf::Operator op("force_summation_psd"); // operator instantiation
op.connect(1, my_nodal_scoping);
op.connect(2, my_elemental_scoping);
op.connect(3, my_streams);
op.connect(4, my_data_sources);
op.connect(6, my_spoint);
op.connect(7, my_abs_rel_key);
op.connect(8, my_signif);
ansys::dpf::FieldsContainer my_force_accumulation = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_moment_accumulation = op.getOutput<ansys::dpf::FieldsContainer>(1);
ansys::dpf::FieldsContainer my_forces_on_nodes = op.getOutput<ansys::dpf::FieldsContainer>(10);
ansys::dpf::FieldsContainer my_moments_on_nodes = op.getOutput<ansys::dpf::FieldsContainer>(11);

result: euler load buckling

Description

Computing Euler's Critical Load. Formula: Ncr = nEIpipi /(L*L)

Inputs

pin 5requested
field_beam_end_conditionname
(data_sources | field)expected type(s)

This pin contains file csv or field of beam's end condition added by the user. If there's no file added, it would take value of all beam's end condition as 1.

pin 6requested
field_beam_moment_inertianame
(field)expected type(s)

Field of beam's moment inertia

pin 7requested
field_beam_young_modulusname
(field)expected type(s)

Field of beam's young modulus

pin 8requested
field_beam_lengthname
(field)expected type(s)

Field of beam's length

Outputs

pin 0requested
field_euler_critical_loadname
(field)expected type(s)

This field contains Euler's Critical Load about the principle axis of the cross section having the least moment of inertia.

pin 1requested
field_euler_critical_load_yyname
(field)expected type(s)

This field contains Euler's Critical Load on axis y.

pin 2requested
field_euler_critical_load_zzname
(field)expected type(s)

This field contains Euler's Critical Load on axis z.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: euler_load_buckling
  • full name: result.euler_load_buckling
  • internal name: euler_load_buckling
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.euler_load_buckling() # operator instantiation
op.inputs.field_beam_end_condition.Connect(my_field_beam_end_condition)
op.inputs.field_beam_moment_inertia.Connect(my_field_beam_moment_inertia)
op.inputs.field_beam_young_modulus.Connect(my_field_beam_young_modulus)
op.inputs.field_beam_length.Connect(my_field_beam_length)
my_field_euler_critical_load = op.outputs.field_euler_critical_load.GetData()
my_field_euler_critical_load_yy = op.outputs.field_euler_critical_load_yy.GetData()
my_field_euler_critical_load_zz = op.outputs.field_euler_critical_load_zz.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.euler_load_buckling() # operator instantiation
op.inputs.field_beam_end_condition.connect(my_field_beam_end_condition)
op.inputs.field_beam_moment_inertia.connect(my_field_beam_moment_inertia)
op.inputs.field_beam_young_modulus.connect(my_field_beam_young_modulus)
op.inputs.field_beam_length.connect(my_field_beam_length)
my_field_euler_critical_load = op.outputs.field_euler_critical_load()
my_field_euler_critical_load_yy = op.outputs.field_euler_critical_load_yy()
my_field_euler_critical_load_zz = op.outputs.field_euler_critical_load_zz()
#include "dpf_api.h"

ansys::dpf::Operator op("euler_load_buckling"); // operator instantiation
op.connect(5, my_field_beam_end_condition);
op.connect(6, my_field_beam_moment_inertia);
op.connect(7, my_field_beam_young_modulus);
op.connect(8, my_field_beam_length);
ansys::dpf::Field my_field_euler_critical_load = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_field_euler_critical_load_yy = op.getOutput<ansys::dpf::Field>(1);
ansys::dpf::Field my_field_euler_critical_load_zz = op.getOutput<ansys::dpf::Field>(2);

geo: faces area

Description

Compute the measure of the Faces (surface for 2D faces of a 3D model or length for 1D faces of a 2D model) using default shape functions, except for polygons.

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)
pin 1requested
mesh_scopingname
(scoping)expected type(s)

If not provided, the measure of all Faces in the mesh is computed. If provided, the Scoping needs to have "Faces" location.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: geo
  • plugin: core
  • scripting name: faces_area
  • full name: geo.faces_area
  • internal name: face::area
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.geo.faces_area() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.geo.faces_area() # operator instantiation
op.inputs.mesh.connect(my_mesh)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("face::area"); // operator instantiation
op.connect(0, my_mesh);
op.connect(1, my_mesh_scoping);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: compute stress 3

Description

Computes the stress from an elastic strain field. compute_total_strain limitations are applicable for stress computation Get the 3rd principal component.

Inputs

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Needed to get mesh and material ids. Optional if a data_sources have been connected.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

Needed to get mesh and material ids. Optional if a streams_container have been connected.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10requested
strainname
(fields_container | field)expected type(s)

Field/or fields container containing only the elastic strain field (element nodal).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_stress_3
  • full name: result.compute_stress_3
  • internal name: compute_stress_3
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_stress_3() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.strain.Connect(my_strain)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_stress_3() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.strain.connect(my_strain)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_stress_3"); // operator instantiation
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(9, my_requested_location);
op.connect(10, my_strain);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: correlation

Description

Takes two fields and a weighting and computes their correlation: aMb/(||aMa||.||bMb||). If several b fields are provided (via a fields container), correlation is computed for each of them.

Inputs

pin 0requested
fieldAname
(field | double | vector)expected type(s)

Field a. The reference field.

pin 1requested
fieldBname
(field | fields_container)expected type(s)

Field b. If a fields container is provided, correlation is computed for each field.

pin 2requested
weightsname
(field | fields_container)expected type(s)

Field M, optional weighting for correlation computation.

pin 3requested
absoluteValuename
(bool)expected type(s)

If true, correlation factor is ||aMb||/(||aMa||.||bMb||)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Correlation factor for each input field b.

pin 1requested
indexname
(int32)expected type(s)

If several b are provided, this output contains the index of the highest correlation factor.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: correlation
  • full name: math.correlation
  • internal name: correlation
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.correlation() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
op.inputs.weights.Connect(my_weights)
op.inputs.absoluteValue.Connect(my_absoluteValue)
my_field = op.outputs.field.GetData()
my_index = op.outputs.index.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.correlation() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
op.inputs.weights.connect(my_weights)
op.inputs.absoluteValue.connect(my_absoluteValue)
my_field = op.outputs.field()
my_index = op.outputs.index()
#include "dpf_api.h"

ansys::dpf::Operator op("correlation"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
op.connect(2, my_weights);
op.connect(3, my_absoluteValue);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);
int my_index = op.getOutput<int>(1);

averaging: gauss to node (fields container)

Description

Extrapolates results available at Gauss or quadrature points to nodal points for a field container. The available elements are: Linear quadrangle, parabolic quadrangle, linear hexagonal, quadratic hexagonal, linear tetrahedral, and quadratic tetrahedral.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

The mesh region in this pin is used for extrapolating results available at Gauss or quadrature points to nodal points.

pin 3optional
scopingname
(scoping)expected type(s)

Extrapolating results on the selected scoping. If it is a scoping container, the label must correspond to the one of the fields containers.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: averaging
  • plugin: core
  • scripting name: gauss_to_node_fc
  • full name: averaging.gauss_to_node_fc
  • internal name: gauss_to_node_fc
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.averaging.gauss_to_node_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.mesh.Connect(my_mesh)
op.inputs.scoping.Connect(my_scoping)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.averaging.gauss_to_node_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.mesh.connect(my_mesh)
op.inputs.scoping.connect(my_scoping)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("gauss_to_node_fc"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_mesh);
op.connect(3, my_scoping);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: mac

Description

Computes MAC Matrix between two fields container, both for real and complex cases. For mixed cases (real-complex and complex) only the real part is considered. Providing inputs with the same component scoping is an user responsability.

Inputs

pin 0requested
fields_containerAname
(fields_container)expected type(s)

Fields Container A.

pin 1requested
fields_containerBname
(fields_container)expected type(s)

Fields Container B.

pin 2requested
weightsname
(field)expected type(s)

Field M, optional weighting for MAC Matrix computation.

Outputs

pin 0requested
fieldname
(field)expected type(s)

MAC Matrix for all the combinations between mode fields of Field Container A and Field Container B. Results listed row by row.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: mac
  • full name: math.mac
  • internal name: mac
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.mac() # operator instantiation
op.inputs.fields_containerA.Connect(my_fields_containerA)
op.inputs.fields_containerB.Connect(my_fields_containerB)
op.inputs.weights.Connect(my_weights)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.mac() # operator instantiation
op.inputs.fields_containerA.connect(my_fields_containerA)
op.inputs.fields_containerB.connect(my_fields_containerB)
op.inputs.weights.connect(my_weights)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("mac"); // operator instantiation
op.connect(0, my_fields_containerA);
op.connect(1, my_fields_containerB);
op.connect(2, my_weights);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: workflow energy per component

Description

Calculates the cumulated energy per component (Named Selection). For cyclic and multistage models, the expansion will be automatically done.

Inputs

pin 0optional
time_scopingname
(scoping)expected type(s)
pin 1optional
mesh_scopingname
(scoping | scopings_container)expected type(s)

When the input is a scoping, it is treated as the master scoping. All named selections will intersect with it. When the input is a scopings container, named selections will not be needed.

pin 2optional
energy_typename
(int32)expected type(s)

Type of energy to be processed: (0: Strain + Kinetic energy (default), 1: Strain energy, 2: Kinetic energy, 3: All energy types)

pin 4requested
data_sourcesname
(data_sources)expected type(s)
pin 5, 6...optional, ellipsis
named_selectionname
(string)expected type(s)

Named Selections. Intersection of all Named Selections with the master scoping will be done.

Outputs

pin 0requested
component_energyname
(fields_container)expected type(s)
pin 1requested
component_energy_percentagename
(fields_container)expected type(s)
pin 2optional
component_total_energyname
(fields_container)expected type(s)
pin 3optional
component_total_energy_percentagename
(fields_container)expected type(s)
pin 4optional
component_strain_energyname
(fields_container)expected type(s)
pin 5optional
component_strain_energy_percentagename
(fields_container)expected type(s)
pin 6optional
component_kinetic_energyname
(fields_container)expected type(s)
pin 7optional
component_kinetic_energy_percentagename
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: workflow_energy_per_component
  • full name: result.workflow_energy_per_component
  • internal name: workflow_energy_per_component
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.workflow_energy_per_component() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.energy_type.Connect(my_energy_type)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.named_selection1.Connect(my_named_selection_1)
op.inputs.named_selection2.Connect(my_named_selection_2)
my_component_energy = op.outputs.component_energy.GetData()
my_component_energy_percentage = op.outputs.component_energy_percentage.GetData()
my_component_total_energy = op.outputs.component_total_energy.GetData()
my_component_total_energy_percentage = op.outputs.component_total_energy_percentage.GetData()
my_component_strain_energy = op.outputs.component_strain_energy.GetData()
my_component_strain_energy_percentage = op.outputs.component_strain_energy_percentage.GetData()
my_component_kinetic_energy = op.outputs.component_kinetic_energy.GetData()
my_component_kinetic_energy_percentage = op.outputs.component_kinetic_energy_percentage.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.workflow_energy_per_component() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.energy_type.connect(my_energy_type)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.named_selection1.connect(my_named_selection_1)
op.inputs.named_selection2.connect(my_named_selection_2)
my_component_energy = op.outputs.component_energy()
my_component_energy_percentage = op.outputs.component_energy_percentage()
my_component_total_energy = op.outputs.component_total_energy()
my_component_total_energy_percentage = op.outputs.component_total_energy_percentage()
my_component_strain_energy = op.outputs.component_strain_energy()
my_component_strain_energy_percentage = op.outputs.component_strain_energy_percentage()
my_component_kinetic_energy = op.outputs.component_kinetic_energy()
my_component_kinetic_energy_percentage = op.outputs.component_kinetic_energy_percentage()
#include "dpf_api.h"

ansys::dpf::Operator op("workflow_energy_per_component"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_energy_type);
op.connect(4, my_data_sources);
op.connect(5, my_named_selection_1);
op.connect(6, my_named_selection_2);
ansys::dpf::FieldsContainer my_component_energy = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_component_energy_percentage = op.getOutput<ansys::dpf::FieldsContainer>(1);
ansys::dpf::FieldsContainer my_component_total_energy = op.getOutput<ansys::dpf::FieldsContainer>(2);
ansys::dpf::FieldsContainer my_component_total_energy_percentage = op.getOutput<ansys::dpf::FieldsContainer>(3);
ansys::dpf::FieldsContainer my_component_strain_energy = op.getOutput<ansys::dpf::FieldsContainer>(4);
ansys::dpf::FieldsContainer my_component_strain_energy_percentage = op.getOutput<ansys::dpf::FieldsContainer>(5);
ansys::dpf::FieldsContainer my_component_kinetic_energy = op.getOutput<ansys::dpf::FieldsContainer>(6);
ansys::dpf::FieldsContainer my_component_kinetic_energy_percentage = op.getOutput<ansys::dpf::FieldsContainer>(7);

result: pretension

Description

Reads the pretension adjustment and tension force. Rotation is not allowed for these results.

Inputs

pin 0optional
time_scopingname
(scopings_container | scoping)expected type(s)
pin 1optional
mesh_scopingname
(scopings_container | scoping)expected type(s)
pin 2optional
fields_containername
(fields_container)expected type(s)
pin 3requested
streams_containername
(streams_container | stream)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)
pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

mesh. If cylic expansion is to be done, mesh of the base sector

pin 14optional
read_cyclicname
(enum dataProcessing::ECyclicReading | int32)expected type(s)

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)

pin 15optional
expanded_meshed_regionname
(abstract_meshed_region | meshes_container)expected type(s)

mesh expanded, use if cyclic expansion is to be done.

pin 18optional
sectors_to_expandname
(vector | scoping | scopings_container)expected type(s)

sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done.

pin 19optional
phiname
(double)expected type(s)

angle phi in degrees (default value 0.0), use if cyclic expansion is to be done.

Outputs

pin 0requested
adjustmentname
(fields_container)expected type(s)

Adjustment

pin 1requested
tension_forcename
(fields_container)expected type(s)

Tension Force

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: pretension
  • full name: result.pretension
  • internal name: mapdl::pretension
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.pretension() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.expanded_meshed_region.Connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.Connect(my_sectors_to_expand)
op.inputs.phi.Connect(my_phi)
my_adjustment = op.outputs.adjustment.GetData()
my_tension_force = op.outputs.tension_force.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.pretension() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.fields_container.connect(my_fields_container)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.expanded_meshed_region.connect(my_expanded_meshed_region)
op.inputs.sectors_to_expand.connect(my_sectors_to_expand)
op.inputs.phi.connect(my_phi)
my_adjustment = op.outputs.adjustment()
my_tension_force = op.outputs.tension_force()
#include "dpf_api.h"

ansys::dpf::Operator op("mapdl::pretension"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_fields_container);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(14, my_read_cyclic);
op.connect(15, my_expanded_meshed_region);
op.connect(18, my_sectors_to_expand);
op.connect(19, my_phi);
ansys::dpf::FieldsContainer my_adjustment = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_tension_force = op.getOutput<ansys::dpf::FieldsContainer>(1);

result: rom data provider

Description

Set the required data for the invariant terms computation (reduced matrices, lumped mass matrix, modes ...)

Inputs

pin 0requested
rom_typename
(bool)expected type(s)

If this pin is set to true, customized rom data must be given

pin 1requested
reduced_stiff_matrixname
(fields_container)expected type(s)

FieldsContainers containing the reduced Stiffness matrix

pin 2requested
reduced_damping_matrixname
(fields_container)expected type(s)

FieldsContainers containing the reduced Mass matrix

pin 3requested
reduced_mass_matrixname
(fields_container)expected type(s)

FieldsContainers containing the reduced Damp matrix

pin 4requested
data_sourcesname
(data_sources)expected type(s)
pin 5requested
reduced_rhs_vectorname
(fields_container)expected type(s)

FieldsContainers containing the reduced RHS vector

pin 6requested
lumped_mass_matrixname
(fields_container)expected type(s)

FieldsContainers containing the lumped Mass matrix

pin 7requested
mode_shapesname
(fields_container)expected type(s)

FieldsContainers containing the customized mode shapes

Outputs

pin 0requested
rom_matricesname
(fields_container)expected type(s)

FieldsContainers containing the reduced matrices

pin 1requested
mode_shapesname
(fields_container)expected type(s)

FieldsContainers containing the mode shapes, which are CST and NOR for the cms method

pin 2requested
lumped_massname
(fields_container)expected type(s)

FieldsContainers containing the lumped mass

pin 3requested
model_dataname
(property_field)expected type(s)

data describing the finite element model

pin 4requested
center_of_massname
(property_field)expected type(s)
pin 5requested
inertia_reliefname
(field)expected type(s)

inertia matrix

pin 6requested
model_sizename
(double)expected type(s)

size of the model

pin 7requested
field_coordinates_and_euler_anglesname
(double)expected type(s)

coordinates and euler angles of all nodes

pin 8requested
nodname
(vector)expected type(s)

ids of master nodes

pin 9requested
meshed_regionname
(abstract_meshed_region)expected type(s)

expanded meshed region.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: rom_data_provider
  • full name: result.rom_data_provider
  • internal name: rom_data_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.rom_data_provider() # operator instantiation
op.inputs.rom_type.Connect(my_rom_type)
op.inputs.reduced_stiff_matrix.Connect(my_reduced_stiff_matrix)
op.inputs.reduced_damping_matrix.Connect(my_reduced_damping_matrix)
op.inputs.reduced_mass_matrix.Connect(my_reduced_mass_matrix)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.reduced_rhs_vector.Connect(my_reduced_rhs_vector)
op.inputs.lumped_mass_matrix.Connect(my_lumped_mass_matrix)
op.inputs.mode_shapes.Connect(my_mode_shapes)
my_rom_matrices = op.outputs.rom_matrices.GetData()
my_mode_shapes = op.outputs.mode_shapes.GetData()
my_lumped_mass = op.outputs.lumped_mass.GetData()
my_model_data = op.outputs.model_data.GetData()
my_center_of_mass = op.outputs.center_of_mass.GetData()
my_inertia_relief = op.outputs.inertia_relief.GetData()
my_model_size = op.outputs.model_size.GetData()
my_field_coordinates_and_euler_angles = op.outputs.field_coordinates_and_euler_angles.GetData()
my_nod = op.outputs.nod.GetData()
my_meshed_region = op.outputs.meshed_region.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.rom_data_provider() # operator instantiation
op.inputs.rom_type.connect(my_rom_type)
op.inputs.reduced_stiff_matrix.connect(my_reduced_stiff_matrix)
op.inputs.reduced_damping_matrix.connect(my_reduced_damping_matrix)
op.inputs.reduced_mass_matrix.connect(my_reduced_mass_matrix)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.reduced_rhs_vector.connect(my_reduced_rhs_vector)
op.inputs.lumped_mass_matrix.connect(my_lumped_mass_matrix)
op.inputs.mode_shapes.connect(my_mode_shapes)
my_rom_matrices = op.outputs.rom_matrices()
my_mode_shapes = op.outputs.mode_shapes()
my_lumped_mass = op.outputs.lumped_mass()
my_model_data = op.outputs.model_data()
my_center_of_mass = op.outputs.center_of_mass()
my_inertia_relief = op.outputs.inertia_relief()
my_model_size = op.outputs.model_size()
my_field_coordinates_and_euler_angles = op.outputs.field_coordinates_and_euler_angles()
my_nod = op.outputs.nod()
my_meshed_region = op.outputs.meshed_region()
#include "dpf_api.h"

ansys::dpf::Operator op("rom_data_provider"); // operator instantiation
op.connect(0, my_rom_type);
op.connect(1, my_reduced_stiff_matrix);
op.connect(2, my_reduced_damping_matrix);
op.connect(3, my_reduced_mass_matrix);
op.connect(4, my_data_sources);
op.connect(5, my_reduced_rhs_vector);
op.connect(6, my_lumped_mass_matrix);
op.connect(7, my_mode_shapes);
ansys::dpf::FieldsContainer my_rom_matrices = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_mode_shapes = op.getOutput<ansys::dpf::FieldsContainer>(1);
ansys::dpf::FieldsContainer my_lumped_mass = op.getOutput<ansys::dpf::FieldsContainer>(2);
ansys::dpf::PropertyField my_model_data = op.getOutput<ansys::dpf::PropertyField>(3);
ansys::dpf::PropertyField my_center_of_mass = op.getOutput<ansys::dpf::PropertyField>(4);
ansys::dpf::Field my_inertia_relief = op.getOutput<ansys::dpf::Field>(5);
double my_model_size = op.getOutput<double>(6);
double my_field_coordinates_and_euler_angles = op.getOutput<double>(7);
std::vector my_nod = op.getOutput<std::vector>(8);
ansys::dpf::MeshedRegion my_meshed_region = op.getOutput<ansys::dpf::MeshedRegion>(9);

result: pres to field

Description

Read the presol generated file from mapdl.

Inputs

pin 0requested
filepathname
(string)expected type(s)

filepath

pin 1optional
columns_to_readname
(int32)expected type(s)

columns_to_read

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: mapdl.pres_to_field
  • full name: result.mapdl.pres_to_field
  • internal name: PRES_Reader
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mapdl.pres_to_field() # operator instantiation
op.inputs.filepath.Connect(my_filepath)
op.inputs.columns_to_read.Connect(my_columns_to_read)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mapdl.pres_to_field() # operator instantiation
op.inputs.filepath.connect(my_filepath)
op.inputs.columns_to_read.connect(my_columns_to_read)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("PRES_Reader"); // operator instantiation
op.connect(0, my_filepath);
op.connect(1, my_columns_to_read);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: prns to field

Description

Read the presol of nodal field generated file from mapdl.

Inputs

pin 0requested
filepathname
(string)expected type(s)

filepath

pin 1optional
columns_to_readname
(int32 | vector)expected type(s)

columns_to_read

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: mapdl.prns_to_field
  • full name: result.mapdl.prns_to_field
  • internal name: PRNS_Reader
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mapdl.prns_to_field() # operator instantiation
op.inputs.filepath.Connect(my_filepath)
op.inputs.columns_to_read.Connect(my_columns_to_read)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mapdl.prns_to_field() # operator instantiation
op.inputs.filepath.connect(my_filepath)
op.inputs.columns_to_read.connect(my_columns_to_read)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("PRNS_Reader"); // operator instantiation
op.connect(0, my_filepath);
op.connect(1, my_columns_to_read);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: remove rigid body motion (field)

Description

Removes rigid body mode from a total displacement field by minimization. Use a reference point in order to subtract its displacement to the result displacement field.

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

field or fields container with only one field is expected

pin 1optional
reference_node_idname
(int32)expected type(s)

Id of the reference entity (node).

pin 7optional
meshname
(abstract_meshed_region)expected type(s)

default is the mesh in the support

Outputs

pin 0requested
fieldname
(field)expected type(s)
pin 1requested
translation_fieldname
(field)expected type(s)

Global rigid translation vector

pin 2requested
rotation_fieldname
(field)expected type(s)

Global rigid rotation angles

pin 3requested
center_fieldname
(field)expected type(s)

Center of the rigid rotation

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: remove_rigid_body_motion
  • full name: result.remove_rigid_body_motion
  • internal name: ExtractRigidBodyMotion
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.remove_rigid_body_motion() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.reference_node_id.Connect(my_reference_node_id)
op.inputs.mesh.Connect(my_mesh)
my_field = op.outputs.field.GetData()
my_translation_field = op.outputs.translation_field.GetData()
my_rotation_field = op.outputs.rotation_field.GetData()
my_center_field = op.outputs.center_field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.remove_rigid_body_motion() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.reference_node_id.connect(my_reference_node_id)
op.inputs.mesh.connect(my_mesh)
my_field = op.outputs.field()
my_translation_field = op.outputs.translation_field()
my_rotation_field = op.outputs.rotation_field()
my_center_field = op.outputs.center_field()
#include "dpf_api.h"

ansys::dpf::Operator op("ExtractRigidBodyMotion"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_reference_node_id);
op.connect(7, my_mesh);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_translation_field = op.getOutput<ansys::dpf::Field>(1);
ansys::dpf::Field my_rotation_field = op.getOutput<ansys::dpf::Field>(2);
ansys::dpf::Field my_center_field = op.getOutput<ansys::dpf::Field>(3);

result: add rigid body motion (field)

Description

Adds a given rigid translation, center and rotation from a displacement field. The rotation is given in terms of rotations angles. Note that the displacement field has to be in the global coordinate system

Inputs

pin 0requested
displacement_fieldname
(field)expected type(s)
pin 1requested
translation_fieldname
(field)expected type(s)
pin 2requested
rotation_fieldname
(field)expected type(s)
pin 3requested
center_fieldname
(field)expected type(s)
pin 7optional
meshname
(abstract_meshed_region)expected type(s)

default is the mesh in the support

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: add_rigid_body_motion
  • full name: result.add_rigid_body_motion
  • internal name: RigidBodyAddition
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.add_rigid_body_motion() # operator instantiation
op.inputs.displacement_field.Connect(my_displacement_field)
op.inputs.translation_field.Connect(my_translation_field)
op.inputs.rotation_field.Connect(my_rotation_field)
op.inputs.center_field.Connect(my_center_field)
op.inputs.mesh.Connect(my_mesh)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.add_rigid_body_motion() # operator instantiation
op.inputs.displacement_field.connect(my_displacement_field)
op.inputs.translation_field.connect(my_translation_field)
op.inputs.rotation_field.connect(my_rotation_field)
op.inputs.center_field.connect(my_center_field)
op.inputs.mesh.connect(my_mesh)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("RigidBodyAddition"); // operator instantiation
op.connect(0, my_displacement_field);
op.connect(1, my_translation_field);
op.connect(2, my_rotation_field);
op.connect(3, my_center_field);
op.connect(7, my_mesh);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: rigid transformation provider

Description

Extracts rigid body transformation from dsub file.

Inputs

pin 3optional
streamsname
(stream)expected type(s)

streams (result file container) (optional)

pin 4requested
data_sourcesname
(data_sources)expected type(s)

data source of dsub file.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: rigid_transformation_provider
  • full name: result.rigid_transformation_provider
  • internal name: mapdl::dsub::rigid_transformation_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.rigid_transformation_provider() # operator instantiation
op.inputs.streams.Connect(my_streams)
op.inputs.data_sources.Connect(my_data_sources)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.rigid_transformation_provider() # operator instantiation
op.inputs.streams.connect(my_streams)
op.inputs.data_sources.connect(my_data_sources)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("mapdl::dsub::rigid_transformation_provider"); // operator instantiation
op.connect(3, my_streams);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute total strain XZ

Description

Computes the strain from a displacement field. Only SOLID185 (B-Bar, Simplified Enhanced Strain, Enhanced Strain formulations), SOLID186 (Full Integration) & SOLID187 elements are supported. Layered elements are not supported. Thermal strains are not supported. Only one value of material properties are allowed per element for isotropic and orthotropic elasticity. Material nonlinearity is not supported 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

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.. Will only be used if no displacement input is given (will be applied on displacement operator).

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Optional if a mesh or a data_sources have been connected. Required if no displacement input have been connected.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Optional if a mesh or a streams_container have been connected, or if the displacement's field has a mesh support. Required if no displacement input have been connected.

pin 5optional
extrapolatename
(int32)expected type(s)

Whether to extrapolate the data from the integration points to the nodes.

pin 6optional
nonlinearname
(int32)expected type(s)

Whether to use nonlinear geometry or nonlinear material (1 = large strain, 2 = hyperelasticity).

pin 7optional
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

The underlying mesh. Optional if a data_sources or a streams_container have been connected, or if the displacement's field has a mesh support.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10optional
displacementname
(fields_container | field)expected type(s)

Field/or fields container containing only the displacement field (nodal). If none specified, read displacements from result file using the data_sources.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_total_strain_XZ
  • full name: result.compute_total_strain_XZ
  • internal name: compute_total_strain_XZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_total_strain_XZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.extrapolate.Connect(my_extrapolate)
op.inputs.nonlinear.Connect(my_nonlinear)
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.displacement.Connect(my_displacement)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_total_strain_XZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.extrapolate.connect(my_extrapolate)
op.inputs.nonlinear.connect(my_nonlinear)
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.displacement.connect(my_displacement)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_total_strain_XZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_extrapolate);
op.connect(6, my_nonlinear);
op.connect(7, my_abstract_meshed_region);
op.connect(9, my_requested_location);
op.connect(10, my_displacement);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: cms matrices provider

Description

Read reduced matrices for cms elements. Extract stiffness, damping, mass matrices and load vector from a subfile.

Inputs

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Data_sources (must contain at list one subfile).

pin 200requested
matrix_formname
(bool)expected type(s)

If this pin i set to true, data are return as matrix form.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Fields container containing in this order : stiffness, damping, mass matrices, and then load vector. But if pin 200 is set to true, it's in matrix form.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: cms_matrices_provider
  • full name: result.cms_matrices_provider
  • internal name: cms_matrices_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.cms_matrices_provider() # operator instantiation
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.matrix_form.Connect(my_matrix_form)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.cms_matrices_provider() # operator instantiation
op.inputs.data_sources.connect(my_data_sources)
op.inputs.matrix_form.connect(my_matrix_form)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("cms_matrices_provider"); // operator instantiation
op.connect(4, my_data_sources);
op.connect(200, my_matrix_form);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: cms subfile info provider

Description

Read required information from a subfile.

Inputs

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Data_sources (must contain at least one subfile).

pin 200requested
cms_subfile_dataname
(bool)expected type(s)

If this pin i set to true, data are return in a field.

pin 300optional
output_maxdof_on_masternodesname
(bool)expected type(s)

If this pin is set to true, compute and add field with max degrees of freedom on master nodes

Outputs

pin 0requested
int32name
(int32)expected type(s)

returns integer values in the order : unit system used, stiffness matrix present key, damping matrix present key, mass matrix present key, number of master nodes, number of virtual nodes

pin 1requested
fieldname
(property_field)expected type(s)

returns integer values in the order : number of load vectors (nvects), number of nodes (nnod), number of virtual nodes (nvnodes), number of modes (nvmodes)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: cms_subfile_info_provider
  • full name: result.cms_subfile_info_provider
  • internal name: cms_subfile_info_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.cms_subfile_info_provider() # operator instantiation
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.cms_subfile_data.Connect(my_cms_subfile_data)
op.inputs.output_maxdof_on_masternodes.Connect(my_output_maxdof_on_masternodes)
my_int32 = op.outputs.int32.GetData()
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.cms_subfile_info_provider() # operator instantiation
op.inputs.data_sources.connect(my_data_sources)
op.inputs.cms_subfile_data.connect(my_cms_subfile_data)
op.inputs.output_maxdof_on_masternodes.connect(my_output_maxdof_on_masternodes)
my_int32 = op.outputs.int32()
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("cms_subfile_info_provider"); // operator instantiation
op.connect(4, my_data_sources);
op.connect(200, my_cms_subfile_data);
op.connect(300, my_output_maxdof_on_masternodes);
int my_int32 = op.getOutput<int>(0);
ansys::dpf::PropertyField my_field = op.getOutput<ansys::dpf::PropertyField>(1);

result: cms dst table provider

Description

Read CST table from a subfile.

Inputs

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Data_sources (must contain at least one subfile).

Outputs

pin 0requested
dst_tablename
(property_field)expected type(s)

returns integer values of the dst table

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: cms_dst_table_provider
  • full name: result.cms_dst_table_provider
  • internal name: cms_dst_table_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.cms_dst_table_provider() # operator instantiation
op.inputs.data_sources.Connect(my_data_sources)
my_dst_table = op.outputs.dst_table.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.cms_dst_table_provider() # operator instantiation
op.inputs.data_sources.connect(my_data_sources)
my_dst_table = op.outputs.dst_table()
#include "dpf_api.h"

ansys::dpf::Operator op("cms_dst_table_provider"); // operator instantiation
op.connect(4, my_data_sources);
ansys::dpf::PropertyField my_dst_table = op.getOutput<ansys::dpf::PropertyField>(0);

result: total mass

Description

Reads total mass from mode file.

Inputs

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Data sources (must contain at least one mode file).

Outputs

pin 0requested
massname
(double)expected type(s)

the unit should be grabbed from the rst file

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: total_mass
  • full name: result.total_mass
  • internal name: mapdl::mode::total_mass
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.total_mass() # operator instantiation
op.inputs.data_sources.Connect(my_data_sources)
my_mass = op.outputs.mass.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.total_mass() # operator instantiation
op.inputs.data_sources.connect(my_data_sources)
my_mass = op.outputs.mass()
#include "dpf_api.h"

ansys::dpf::Operator op("mapdl::mode::total_mass"); // operator instantiation
op.connect(4, my_data_sources);
double my_mass = op.getOutput<double>(0);

invariant: eigen vectors (on fields container)

Description

Computes the element-wise Eigen vectors for each tensor in the fields of the field container.

Inputs

pin 0requested
fields_containername
(fields_container | field)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: invariant
  • plugin: mapdl
  • scripting name: eigen_vectors_fc
  • full name: invariant.eigen_vectors_fc
  • internal name: eig_vectors_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.eigen_vectors_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.eigen_vectors_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("eig_vectors_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

invariant: eigen vectors (on field)

Description

Computes the element-wise Eigen vectors for each tensor in the field.

Inputs

pin 0requested
fieldname
(fields_container | field)expected type(s)

field or fields container with only one field is expected

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: invariant
  • plugin: mapdl
  • scripting name: eigen_vectors
  • full name: invariant.eigen_vectors
  • internal name: eig_vectors
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.eigen_vectors() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.eigen_vectors() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("eig_vectors"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

result: mapdl material properties

Description

Read the values of the properties of a material for a given materials property field (property field that contains materials information for each element of a mesh).It returns a fields container containing a field for each material property, with only one value per material. The following keys can be used: Young's modulus (keys: EX, EY, EZ), Poisson's ratio (keys: NUXY, NUYZ, NUXZ), Shear Modulus (keys: GXY, GYZ, GXZ), Coefficient of Thermal Expansion (keys: ALPX, ALPY, ALPZ), Volumic Mass (key: DENS), second Lame's coefficient (key: MU), Damping coefficient (key: DAMP), thermal Conductivity (keys: KXX, KYY, KZZ), Resistivity (keys: RSVX, RSVY, RSVZ), Specific heat in constant volume (key: C), Film coefficient (key: HF), Viscosity (key: VISC), Emissivity (key: EMIS).

Inputs

pin 0requested
properties_namename
(string | vector)expected type(s)
pin 1requested
materialsname
(property_field)expected type(s)

Property field that contains a material id per element.

pin 3requested
streams_containername
(streams_container)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
properties_valuename
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: mapdl_material_properties
  • full name: result.mapdl_material_properties
  • internal name: mapdl_material_properties
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mapdl_material_properties() # operator instantiation
op.inputs.properties_name.Connect(my_properties_name)
op.inputs.materials.Connect(my_materials)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_properties_value = op.outputs.properties_value.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mapdl_material_properties() # operator instantiation
op.inputs.properties_name.connect(my_properties_name)
op.inputs.materials.connect(my_materials)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_properties_value = op.outputs.properties_value()
#include "dpf_api.h"

ansys::dpf::Operator op("mapdl_material_properties"); // operator instantiation
op.connect(0, my_properties_name);
op.connect(1, my_materials);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_properties_value = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: mapdl_section

Description

Read the values of the section properties for a given section property field (property field that contains section information for each element of a mesh). The following keys can be used: Thickness, NumLayers. For layered elements, the following keys can be used: Thickness, MatID, Orientation, NumIntPoints.

Inputs

pin 0requested
properties_namename
(string | vector)expected type(s)
pin 1optional
sectionname
(property_field)expected type(s)

Property field that contains a section id per element.(optional)

pin 3requested
streams_containername
(streams_container)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)
pin 5optional
layer_propertyname
(bool)expected type(s)

Property requested is layered. Default = False.

pin 6optional
layers_requestedname
(vector)expected type(s)

Array with layers requested for the section. Default = AllLayers.

Outputs

pin 0requested
properties_valuename
(fields_container)expected type(s)
pin 1requested
layers_per_sectionname
(property_field)expected type(s)

Only available if layer_property option is set to True.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: mapdl_section
  • full name: result.mapdl_section
  • internal name: mapdl_section_properties
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mapdl_section() # operator instantiation
op.inputs.properties_name.Connect(my_properties_name)
op.inputs.section.Connect(my_section)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.layer_property.Connect(my_layer_property)
op.inputs.layers_requested.Connect(my_layers_requested)
my_properties_value = op.outputs.properties_value.GetData()
my_layers_per_section = op.outputs.layers_per_section.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mapdl_section() # operator instantiation
op.inputs.properties_name.connect(my_properties_name)
op.inputs.section.connect(my_section)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.layer_property.connect(my_layer_property)
op.inputs.layers_requested.connect(my_layers_requested)
my_properties_value = op.outputs.properties_value()
my_layers_per_section = op.outputs.layers_per_section()
#include "dpf_api.h"

ansys::dpf::Operator op("mapdl_section_properties"); // operator instantiation
op.connect(0, my_properties_name);
op.connect(1, my_section);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_layer_property);
op.connect(6, my_layers_requested);
ansys::dpf::FieldsContainer my_properties_value = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::PropertyField my_layers_per_section = op.getOutput<ansys::dpf::PropertyField>(1);

invariant: convertnum operator

Description

Converts a fields container from one mapdl ordering to another mapdl ordering. Supported mapdl ordering are BCS=0, FUL=1, NOD=2.

Inputs

pin 0requested
input_orderingname
(int32)expected type(s)

Input ordering number

pin 1requested
output_orderingname
(int32)expected type(s)

Output ordering number

pin 2requested
fields_containername
(fields_container)expected type(s)

Expect fields container

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Data_sources (must contain the full file).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: invariant
  • plugin: mapdl
  • scripting name: convertnum_op
  • full name: invariant.convertnum_op
  • internal name: convertnum_op
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.invariant.convertnum_op() # operator instantiation
op.inputs.input_ordering.Connect(my_input_ordering)
op.inputs.output_ordering.Connect(my_output_ordering)
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.data_sources.Connect(my_data_sources)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.invariant.convertnum_op() # operator instantiation
op.inputs.input_ordering.connect(my_input_ordering)
op.inputs.output_ordering.connect(my_output_ordering)
op.inputs.fields_container.connect(my_fields_container)
op.inputs.data_sources.connect(my_data_sources)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("convertnum_op"); // operator instantiation
op.connect(0, my_input_ordering);
op.connect(1, my_output_ordering);
op.connect(2, my_fields_container);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute invariant terms rbd

Description

Set the required data for the invariant terms computation (reduced matrices, lumped mass matrix, modes ...)

Inputs

pin 0requested
rom_matricesname
(fields_container)expected type(s)

FieldsContainers containing the reduced matrices

pin 1requested
mode_shapesname
(fields_container)expected type(s)

FieldsContainers containing the mode shapes, which are CST and NOR for the cms method

pin 2requested
lumped_massname
(fields_container)expected type(s)

FieldsContainers containing the lumped mass

pin 3requested
model_dataname
(fields_container)expected type(s)

data describing the finite element model

pin 4requested
center_of_massname
(fields_container)expected type(s)
pin 5requested
inertia_reliefname
(fields_container)expected type(s)

inertia matrix

pin 6requested
model_sizename
(double)expected type(s)

model size

pin 7requested
field_coordinatesname
(field)expected type(s)

coordinates of all nodes

pin 8requested
nodname
(vector)expected type(s)
pin 9optional
constraint_mode_checkname
(bool)expected type(s)

if true, the orthogonality of the constraint modes are checked. Default is false.

Outputs

pin 0requested
model_dataname
(property_field)expected type(s)

data describing the finite element model

pin 1requested
center_of_massname
(field)expected type(s)

center of mass of the body

pin 2requested
inertia_reliefname
(field)expected type(s)

inertia matrix

pin 3requested
model_sizename
(property_field)expected type(s)
pin 4requested
master_node_coordinatesname
(vector)expected type(s)
pin 5requested
v_trsfname
(vector)expected type(s)

translational and rotational shape functions

pin 6requested
k_matname
(field)expected type(s)
pin 7requested
mass_matname
(field)expected type(s)
pin 8requested
c_matname
(field)expected type(s)
pin 9requested
rhsname
(field)expected type(s)
pin 10requested
dnname
(vector)expected type(s)
pin 11requested
dr_cross_nname
(vector)expected type(s)
pin 12requested
drnname
(vector)expected type(s)
pin 13requested
dn_cross_nname
(vector)expected type(s)
pin 14requested
dnx_yname
(vector)expected type(s)
pin 15requested
dny_yname
(vector)expected type(s)
pin 16requested
dnz_yname
(vector)expected type(s)
pin 17requested
dyx_nname
(vector)expected type(s)
pin 18requested
dyy_nname
(vector)expected type(s)
pin 19requested
dyz_nname
(vector)expected type(s)
pin 20requested
dnxnname
(vector)expected type(s)
pin 21requested
dnynname
(vector)expected type(s)
pin 22requested
dnznname
(vector)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: compute_invariant_terms_rbd
  • full name: result.compute_invariant_terms_rbd
  • internal name: compute_invariant_terms_rbd
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_invariant_terms_rbd() # operator instantiation
op.inputs.rom_matrices.Connect(my_rom_matrices)
op.inputs.mode_shapes.Connect(my_mode_shapes)
op.inputs.lumped_mass.Connect(my_lumped_mass)
op.inputs.model_data.Connect(my_model_data)
op.inputs.center_of_mass.Connect(my_center_of_mass)
op.inputs.inertia_relief.Connect(my_inertia_relief)
op.inputs.model_size.Connect(my_model_size)
op.inputs.field_coordinates.Connect(my_field_coordinates)
op.inputs.nod.Connect(my_nod)
op.inputs.constraint_mode_check.Connect(my_constraint_mode_check)
my_model_data = op.outputs.model_data.GetData()
my_center_of_mass = op.outputs.center_of_mass.GetData()
my_inertia_relief = op.outputs.inertia_relief.GetData()
my_model_size = op.outputs.model_size.GetData()
my_master_node_coordinates = op.outputs.master_node_coordinates.GetData()
my_v_trsf = op.outputs.v_trsf.GetData()
my_k_mat = op.outputs.k_mat.GetData()
my_mass_mat = op.outputs.mass_mat.GetData()
my_c_mat = op.outputs.c_mat.GetData()
my_rhs = op.outputs.rhs.GetData()
my_dn = op.outputs.dn.GetData()
my_dr_cross_n = op.outputs.dr_cross_n.GetData()
my_drn = op.outputs.drn.GetData()
my_dn_cross_n = op.outputs.dn_cross_n.GetData()
my_dnx_y = op.outputs.dnx_y.GetData()
my_dny_y = op.outputs.dny_y.GetData()
my_dnz_y = op.outputs.dnz_y.GetData()
my_dyx_n = op.outputs.dyx_n.GetData()
my_dyy_n = op.outputs.dyy_n.GetData()
my_dyz_n = op.outputs.dyz_n.GetData()
my_dnxn = op.outputs.dnxn.GetData()
my_dnyn = op.outputs.dnyn.GetData()
my_dnzn = op.outputs.dnzn.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_invariant_terms_rbd() # operator instantiation
op.inputs.rom_matrices.connect(my_rom_matrices)
op.inputs.mode_shapes.connect(my_mode_shapes)
op.inputs.lumped_mass.connect(my_lumped_mass)
op.inputs.model_data.connect(my_model_data)
op.inputs.center_of_mass.connect(my_center_of_mass)
op.inputs.inertia_relief.connect(my_inertia_relief)
op.inputs.model_size.connect(my_model_size)
op.inputs.field_coordinates.connect(my_field_coordinates)
op.inputs.nod.connect(my_nod)
op.inputs.constraint_mode_check.connect(my_constraint_mode_check)
my_model_data = op.outputs.model_data()
my_center_of_mass = op.outputs.center_of_mass()
my_inertia_relief = op.outputs.inertia_relief()
my_model_size = op.outputs.model_size()
my_master_node_coordinates = op.outputs.master_node_coordinates()
my_v_trsf = op.outputs.v_trsf()
my_k_mat = op.outputs.k_mat()
my_mass_mat = op.outputs.mass_mat()
my_c_mat = op.outputs.c_mat()
my_rhs = op.outputs.rhs()
my_dn = op.outputs.dn()
my_dr_cross_n = op.outputs.dr_cross_n()
my_drn = op.outputs.drn()
my_dn_cross_n = op.outputs.dn_cross_n()
my_dnx_y = op.outputs.dnx_y()
my_dny_y = op.outputs.dny_y()
my_dnz_y = op.outputs.dnz_y()
my_dyx_n = op.outputs.dyx_n()
my_dyy_n = op.outputs.dyy_n()
my_dyz_n = op.outputs.dyz_n()
my_dnxn = op.outputs.dnxn()
my_dnyn = op.outputs.dnyn()
my_dnzn = op.outputs.dnzn()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_invariant_terms_rbd"); // operator instantiation
op.connect(0, my_rom_matrices);
op.connect(1, my_mode_shapes);
op.connect(2, my_lumped_mass);
op.connect(3, my_model_data);
op.connect(4, my_center_of_mass);
op.connect(5, my_inertia_relief);
op.connect(6, my_model_size);
op.connect(7, my_field_coordinates);
op.connect(8, my_nod);
op.connect(9, my_constraint_mode_check);
ansys::dpf::PropertyField my_model_data = op.getOutput<ansys::dpf::PropertyField>(0);
ansys::dpf::Field my_center_of_mass = op.getOutput<ansys::dpf::Field>(1);
ansys::dpf::Field my_inertia_relief = op.getOutput<ansys::dpf::Field>(2);
ansys::dpf::PropertyField my_model_size = op.getOutput<ansys::dpf::PropertyField>(3);
std::vector my_master_node_coordinates = op.getOutput<std::vector>(4);
std::vector my_v_trsf = op.getOutput<std::vector>(5);
ansys::dpf::Field my_k_mat = op.getOutput<ansys::dpf::Field>(6);
ansys::dpf::Field my_mass_mat = op.getOutput<ansys::dpf::Field>(7);
ansys::dpf::Field my_c_mat = op.getOutput<ansys::dpf::Field>(8);
ansys::dpf::Field my_rhs = op.getOutput<ansys::dpf::Field>(9);
std::vector my_dn = op.getOutput<std::vector>(10);
std::vector my_dr_cross_n = op.getOutput<std::vector>(11);
std::vector my_drn = op.getOutput<std::vector>(12);
std::vector my_dn_cross_n = op.getOutput<std::vector>(13);
std::vector my_dnx_y = op.getOutput<std::vector>(14);
std::vector my_dny_y = op.getOutput<std::vector>(15);
std::vector my_dnz_y = op.getOutput<std::vector>(16);
std::vector my_dyx_n = op.getOutput<std::vector>(17);
std::vector my_dyy_n = op.getOutput<std::vector>(18);
std::vector my_dyz_n = op.getOutput<std::vector>(19);
std::vector my_dnxn = op.getOutput<std::vector>(20);
std::vector my_dnyn = op.getOutput<std::vector>(21);
std::vector my_dnzn = op.getOutput<std::vector>(22);

result: transform invariant terms rbd

Description

Transform invariant terms rbd based on a coordinate system (translation + rotation).

Inputs

pin 0requested
rotation_matrixname
(field)expected type(s)

3-3 rotation matrix.

pin 1requested
coordinate_systemname
(field)expected type(s)

origin of the new coordinate system.

pin 2requested
model_dataname
(property_field)expected type(s)

data describing the finite element model

pin 3requested
center_of_massname
(field)expected type(s)

center of mass of the body

pin 4requested
inertia_reliefname
(field)expected type(s)

inertia matrix

pin 5requested
model_sizename
(double)expected type(s)

size of the diagonal box containing the body

pin 6requested
master_node_coordinatesname
(vector)expected type(s)
pin 7requested
v_trsfname
(vector)expected type(s)

translational and rotational shape functions

pin 8requested
k_matname
(field)expected type(s)
pin 9requested
mass_matname
(field)expected type(s)
pin 10requested
c_matname
(field)expected type(s)
pin 11requested
rhsname
(field)expected type(s)
pin 12requested
dnname
(vector)expected type(s)
pin 13requested
dr_cross_nname
(vector)expected type(s)
pin 14requested
drnname
(vector)expected type(s)
pin 15requested
dn_cross_nname
(vector)expected type(s)
pin 16requested
dnx_yname
(vector)expected type(s)
pin 17requested
dny_yname
(vector)expected type(s)
pin 18requested
dnz_yname
(vector)expected type(s)
pin 19requested
dyx_nname
(vector)expected type(s)
pin 20requested
dyy_nname
(vector)expected type(s)
pin 21requested
dyz_nname
(vector)expected type(s)
pin 22requested
dnxnname
(vector)expected type(s)
pin 23requested
dnynname
(vector)expected type(s)
pin 24requested
dnznname
(vector)expected type(s)

Outputs

pin 0requested
model_dataname
(property_field)expected type(s)

data describing the finite element model

pin 1requested
center_of_massname
(field)expected type(s)

center of mass of the body

pin 2requested
inertia_reliefname
(field)expected type(s)

inertia matrix

pin 3requested
model_sizename
(property_field)expected type(s)
pin 4requested
master_node_coordinatesname
(vector)expected type(s)
pin 5requested
v_trsfname
(vector)expected type(s)

translational and rotational shape functions

pin 6requested
k_matname
(field)expected type(s)
pin 7requested
mass_matname
(field)expected type(s)
pin 8requested
c_matname
(field)expected type(s)
pin 9requested
rhsname
(field)expected type(s)
pin 10requested
dnname
(vector)expected type(s)
pin 11requested
dr_cross_nname
(vector)expected type(s)
pin 12requested
drnname
(vector)expected type(s)
pin 13requested
dn_cross_nname
(vector)expected type(s)
pin 14requested
dnx_yname
(vector)expected type(s)
pin 15requested
dny_yname
(vector)expected type(s)
pin 16requested
dnz_yname
(vector)expected type(s)
pin 17requested
dyx_nname
(vector)expected type(s)
pin 18requested
dyy_nname
(vector)expected type(s)
pin 19requested
dyz_nname
(vector)expected type(s)
pin 20requested
dnxnname
(vector)expected type(s)
pin 21requested
dnynname
(vector)expected type(s)
pin 22requested
dnznname
(vector)expected type(s)

Configurations

inplaceThe output is written over the input to save memory if this config is set to true.
(bool)expected type(s)
falsedefault value
: The output is written over the input to save memory if this config is set to true.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: transform_invariant_terms_rbd
  • full name: result.transform_invariant_terms_rbd
  • internal name: transform_invariant_terms_rbd
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.transform_invariant_terms_rbd() # operator instantiation
op.inputs.rotation_matrix.Connect(my_rotation_matrix)
op.inputs.coordinate_system.Connect(my_coordinate_system)
op.inputs.model_data.Connect(my_model_data)
op.inputs.center_of_mass.Connect(my_center_of_mass)
op.inputs.inertia_relief.Connect(my_inertia_relief)
op.inputs.model_size.Connect(my_model_size)
op.inputs.master_node_coordinates.Connect(my_master_node_coordinates)
op.inputs.v_trsf.Connect(my_v_trsf)
op.inputs.k_mat.Connect(my_k_mat)
op.inputs.mass_mat.Connect(my_mass_mat)
op.inputs.c_mat.Connect(my_c_mat)
op.inputs.rhs.Connect(my_rhs)
op.inputs.dn.Connect(my_dn)
op.inputs.dr_cross_n.Connect(my_dr_cross_n)
op.inputs.drn.Connect(my_drn)
op.inputs.dn_cross_n.Connect(my_dn_cross_n)
op.inputs.dnx_y.Connect(my_dnx_y)
op.inputs.dny_y.Connect(my_dny_y)
op.inputs.dnz_y.Connect(my_dnz_y)
op.inputs.dyx_n.Connect(my_dyx_n)
op.inputs.dyy_n.Connect(my_dyy_n)
op.inputs.dyz_n.Connect(my_dyz_n)
op.inputs.dnxn.Connect(my_dnxn)
op.inputs.dnyn.Connect(my_dnyn)
op.inputs.dnzn.Connect(my_dnzn)
my_model_data = op.outputs.model_data.GetData()
my_center_of_mass = op.outputs.center_of_mass.GetData()
my_inertia_relief = op.outputs.inertia_relief.GetData()
my_model_size = op.outputs.model_size.GetData()
my_master_node_coordinates = op.outputs.master_node_coordinates.GetData()
my_v_trsf = op.outputs.v_trsf.GetData()
my_k_mat = op.outputs.k_mat.GetData()
my_mass_mat = op.outputs.mass_mat.GetData()
my_c_mat = op.outputs.c_mat.GetData()
my_rhs = op.outputs.rhs.GetData()
my_dn = op.outputs.dn.GetData()
my_dr_cross_n = op.outputs.dr_cross_n.GetData()
my_drn = op.outputs.drn.GetData()
my_dn_cross_n = op.outputs.dn_cross_n.GetData()
my_dnx_y = op.outputs.dnx_y.GetData()
my_dny_y = op.outputs.dny_y.GetData()
my_dnz_y = op.outputs.dnz_y.GetData()
my_dyx_n = op.outputs.dyx_n.GetData()
my_dyy_n = op.outputs.dyy_n.GetData()
my_dyz_n = op.outputs.dyz_n.GetData()
my_dnxn = op.outputs.dnxn.GetData()
my_dnyn = op.outputs.dnyn.GetData()
my_dnzn = op.outputs.dnzn.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.transform_invariant_terms_rbd() # operator instantiation
op.inputs.rotation_matrix.connect(my_rotation_matrix)
op.inputs.coordinate_system.connect(my_coordinate_system)
op.inputs.model_data.connect(my_model_data)
op.inputs.center_of_mass.connect(my_center_of_mass)
op.inputs.inertia_relief.connect(my_inertia_relief)
op.inputs.model_size.connect(my_model_size)
op.inputs.master_node_coordinates.connect(my_master_node_coordinates)
op.inputs.v_trsf.connect(my_v_trsf)
op.inputs.k_mat.connect(my_k_mat)
op.inputs.mass_mat.connect(my_mass_mat)
op.inputs.c_mat.connect(my_c_mat)
op.inputs.rhs.connect(my_rhs)
op.inputs.dn.connect(my_dn)
op.inputs.dr_cross_n.connect(my_dr_cross_n)
op.inputs.drn.connect(my_drn)
op.inputs.dn_cross_n.connect(my_dn_cross_n)
op.inputs.dnx_y.connect(my_dnx_y)
op.inputs.dny_y.connect(my_dny_y)
op.inputs.dnz_y.connect(my_dnz_y)
op.inputs.dyx_n.connect(my_dyx_n)
op.inputs.dyy_n.connect(my_dyy_n)
op.inputs.dyz_n.connect(my_dyz_n)
op.inputs.dnxn.connect(my_dnxn)
op.inputs.dnyn.connect(my_dnyn)
op.inputs.dnzn.connect(my_dnzn)
my_model_data = op.outputs.model_data()
my_center_of_mass = op.outputs.center_of_mass()
my_inertia_relief = op.outputs.inertia_relief()
my_model_size = op.outputs.model_size()
my_master_node_coordinates = op.outputs.master_node_coordinates()
my_v_trsf = op.outputs.v_trsf()
my_k_mat = op.outputs.k_mat()
my_mass_mat = op.outputs.mass_mat()
my_c_mat = op.outputs.c_mat()
my_rhs = op.outputs.rhs()
my_dn = op.outputs.dn()
my_dr_cross_n = op.outputs.dr_cross_n()
my_drn = op.outputs.drn()
my_dn_cross_n = op.outputs.dn_cross_n()
my_dnx_y = op.outputs.dnx_y()
my_dny_y = op.outputs.dny_y()
my_dnz_y = op.outputs.dnz_y()
my_dyx_n = op.outputs.dyx_n()
my_dyy_n = op.outputs.dyy_n()
my_dyz_n = op.outputs.dyz_n()
my_dnxn = op.outputs.dnxn()
my_dnyn = op.outputs.dnyn()
my_dnzn = op.outputs.dnzn()
#include "dpf_api.h"

ansys::dpf::Operator op("transform_invariant_terms_rbd"); // operator instantiation
op.connect(0, my_rotation_matrix);
op.connect(1, my_coordinate_system);
op.connect(2, my_model_data);
op.connect(3, my_center_of_mass);
op.connect(4, my_inertia_relief);
op.connect(5, my_model_size);
op.connect(6, my_master_node_coordinates);
op.connect(7, my_v_trsf);
op.connect(8, my_k_mat);
op.connect(9, my_mass_mat);
op.connect(10, my_c_mat);
op.connect(11, my_rhs);
op.connect(12, my_dn);
op.connect(13, my_dr_cross_n);
op.connect(14, my_drn);
op.connect(15, my_dn_cross_n);
op.connect(16, my_dnx_y);
op.connect(17, my_dny_y);
op.connect(18, my_dnz_y);
op.connect(19, my_dyx_n);
op.connect(20, my_dyy_n);
op.connect(21, my_dyz_n);
op.connect(22, my_dnxn);
op.connect(23, my_dnyn);
op.connect(24, my_dnzn);
ansys::dpf::PropertyField my_model_data = op.getOutput<ansys::dpf::PropertyField>(0);
ansys::dpf::Field my_center_of_mass = op.getOutput<ansys::dpf::Field>(1);
ansys::dpf::Field my_inertia_relief = op.getOutput<ansys::dpf::Field>(2);
ansys::dpf::PropertyField my_model_size = op.getOutput<ansys::dpf::PropertyField>(3);
std::vector my_master_node_coordinates = op.getOutput<std::vector>(4);
std::vector my_v_trsf = op.getOutput<std::vector>(5);
ansys::dpf::Field my_k_mat = op.getOutput<ansys::dpf::Field>(6);
ansys::dpf::Field my_mass_mat = op.getOutput<ansys::dpf::Field>(7);
ansys::dpf::Field my_c_mat = op.getOutput<ansys::dpf::Field>(8);
ansys::dpf::Field my_rhs = op.getOutput<ansys::dpf::Field>(9);
std::vector my_dn = op.getOutput<std::vector>(10);
std::vector my_dr_cross_n = op.getOutput<std::vector>(11);
std::vector my_drn = op.getOutput<std::vector>(12);
std::vector my_dn_cross_n = op.getOutput<std::vector>(13);
std::vector my_dnx_y = op.getOutput<std::vector>(14);
std::vector my_dny_y = op.getOutput<std::vector>(15);
std::vector my_dnz_y = op.getOutput<std::vector>(16);
std::vector my_dyx_n = op.getOutput<std::vector>(17);
std::vector my_dyy_n = op.getOutput<std::vector>(18);
std::vector my_dyz_n = op.getOutput<std::vector>(19);
std::vector my_dnxn = op.getOutput<std::vector>(20);
std::vector my_dnyn = op.getOutput<std::vector>(21);
std::vector my_dnzn = op.getOutput<std::vector>(22);

result: compute invariant terms motion

Description

Set the required data for the invariant terms computation (reduced matrices, lumped mass matrix, modes ...)

Inputs

pin 0requested
rom_matricesname
(fields_container)expected type(s)

FieldsContainers containing the reduced matrices

pin 1requested
mode_shapesname
(fields_container)expected type(s)

FieldsContainers containing the mode shapes, which are CST and NOR for the cms method

pin 2requested
lumped_massname
(fields_container)expected type(s)

FieldsContainers containing the lumped mass

pin 3requested
model_dataname
(fields_container)expected type(s)

data describing the finite element model

pin 4requested
field_coordinatesname
(field)expected type(s)

coordinates of all nodes

pin 5requested
nodname
(vector)expected type(s)

Outputs

pin 0requested
model_dataname
(property_field)expected type(s)

data describing the finite element model

pin 1requested
mode_shapesname
(fields_container)expected type(s)

FieldsContainers containing the mode shapes, which are CST and NOR for the cms method

pin 2requested
lumped_massname
(fields_container)expected type(s)

FieldsContainers containing the lumped mass

pin 3requested
field_coordinates_and_euler_anglesname
(fields_container)expected type(s)

coordinates and euler angles of all nodes

pin 4requested
nodname
(vector)expected type(s)
pin 5requested
used_node_indexname
(vector)expected type(s)
pin 6requested
eigenvaluename
(vector)expected type(s)
pin 7requested
translational_mode_shapename
(vector)expected type(s)
pin 8requested
rotational_mode_shapename
(vector)expected type(s)
pin 9requested
invrt_1name
(double)expected type(s)
pin 10requested
invrt_2name
(vector)expected type(s)
pin 11requested
invrt_3name
(vector)expected type(s)
pin 12requested
invrt_4name
(vector)expected type(s)
pin 13requested
invrt_5name
(vector)expected type(s)
pin 14requested
invrt_6name
(vector)expected type(s)
pin 15requested
invrt_7name
(vector)expected type(s)
pin 16requested
invrt_8name
(vector)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: compute_invariant_terms_motion
  • full name: result.compute_invariant_terms_motion
  • internal name: compute_invariant_terms_motion
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_invariant_terms_motion() # operator instantiation
op.inputs.rom_matrices.Connect(my_rom_matrices)
op.inputs.mode_shapes.Connect(my_mode_shapes)
op.inputs.lumped_mass.Connect(my_lumped_mass)
op.inputs.model_data.Connect(my_model_data)
op.inputs.field_coordinates.Connect(my_field_coordinates)
op.inputs.nod.Connect(my_nod)
my_model_data = op.outputs.model_data.GetData()
my_mode_shapes = op.outputs.mode_shapes.GetData()
my_lumped_mass = op.outputs.lumped_mass.GetData()
my_field_coordinates_and_euler_angles = op.outputs.field_coordinates_and_euler_angles.GetData()
my_nod = op.outputs.nod.GetData()
my_used_node_index = op.outputs.used_node_index.GetData()
my_eigenvalue = op.outputs.eigenvalue.GetData()
my_translational_mode_shape = op.outputs.translational_mode_shape.GetData()
my_rotational_mode_shape = op.outputs.rotational_mode_shape.GetData()
my_invrt_1 = op.outputs.invrt_1.GetData()
my_invrt_2 = op.outputs.invrt_2.GetData()
my_invrt_3 = op.outputs.invrt_3.GetData()
my_invrt_4 = op.outputs.invrt_4.GetData()
my_invrt_5 = op.outputs.invrt_5.GetData()
my_invrt_6 = op.outputs.invrt_6.GetData()
my_invrt_7 = op.outputs.invrt_7.GetData()
my_invrt_8 = op.outputs.invrt_8.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_invariant_terms_motion() # operator instantiation
op.inputs.rom_matrices.connect(my_rom_matrices)
op.inputs.mode_shapes.connect(my_mode_shapes)
op.inputs.lumped_mass.connect(my_lumped_mass)
op.inputs.model_data.connect(my_model_data)
op.inputs.field_coordinates.connect(my_field_coordinates)
op.inputs.nod.connect(my_nod)
my_model_data = op.outputs.model_data()
my_mode_shapes = op.outputs.mode_shapes()
my_lumped_mass = op.outputs.lumped_mass()
my_field_coordinates_and_euler_angles = op.outputs.field_coordinates_and_euler_angles()
my_nod = op.outputs.nod()
my_used_node_index = op.outputs.used_node_index()
my_eigenvalue = op.outputs.eigenvalue()
my_translational_mode_shape = op.outputs.translational_mode_shape()
my_rotational_mode_shape = op.outputs.rotational_mode_shape()
my_invrt_1 = op.outputs.invrt_1()
my_invrt_2 = op.outputs.invrt_2()
my_invrt_3 = op.outputs.invrt_3()
my_invrt_4 = op.outputs.invrt_4()
my_invrt_5 = op.outputs.invrt_5()
my_invrt_6 = op.outputs.invrt_6()
my_invrt_7 = op.outputs.invrt_7()
my_invrt_8 = op.outputs.invrt_8()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_invariant_terms_motion"); // operator instantiation
op.connect(0, my_rom_matrices);
op.connect(1, my_mode_shapes);
op.connect(2, my_lumped_mass);
op.connect(3, my_model_data);
op.connect(4, my_field_coordinates);
op.connect(5, my_nod);
ansys::dpf::PropertyField my_model_data = op.getOutput<ansys::dpf::PropertyField>(0);
ansys::dpf::FieldsContainer my_mode_shapes = op.getOutput<ansys::dpf::FieldsContainer>(1);
ansys::dpf::FieldsContainer my_lumped_mass = op.getOutput<ansys::dpf::FieldsContainer>(2);
ansys::dpf::FieldsContainer my_field_coordinates_and_euler_angles = op.getOutput<ansys::dpf::FieldsContainer>(3);
std::vector my_nod = op.getOutput<std::vector>(4);
std::vector my_used_node_index = op.getOutput<std::vector>(5);
std::vector my_eigenvalue = op.getOutput<std::vector>(6);
std::vector my_translational_mode_shape = op.getOutput<std::vector>(7);
std::vector my_rotational_mode_shape = op.getOutput<std::vector>(8);
double my_invrt_1 = op.getOutput<double>(9);
std::vector my_invrt_2 = op.getOutput<std::vector>(10);
std::vector my_invrt_3 = op.getOutput<std::vector>(11);
std::vector my_invrt_4 = op.getOutput<std::vector>(12);
std::vector my_invrt_5 = op.getOutput<std::vector>(13);
std::vector my_invrt_6 = op.getOutput<std::vector>(14);
std::vector my_invrt_7 = op.getOutput<std::vector>(15);
std::vector my_invrt_8 = op.getOutput<std::vector>(16);

result: write motion dfmf file

Description

Write the invariant terms and the model data in a motion dfmf file

Inputs

pin 0requested
model_dataname
(property_field)expected type(s)

data describing the finite element model

pin 1requested
mode_shapesname
(fields_container)expected type(s)

FieldsContainers containing the mode shapes, which are CST and NOR for the cms method

pin 2requested
lumped_massname
(fields_container)expected type(s)

FieldsContainers containing the lumped mass

pin 3requested
field_coordinatesname
(field)expected type(s)

coordinates of all nodes

pin 4requested
nodname
(vector)expected type(s)
pin 5requested
used_node_indexname
(vector)expected type(s)
pin 6requested
eigenvaluename
(vector)expected type(s)
pin 7requested
translational_mode_shapename
(vector)expected type(s)
pin 8requested
rotational_mode_shapename
(vector)expected type(s)
pin 9requested
invrt_1name
(double)expected type(s)
pin 10requested
invrt_2name
(vector)expected type(s)
pin 11requested
invrt_3name
(vector)expected type(s)
pin 12requested
invrt_4name
(vector)expected type(s)
pin 13requested
invrt_5name
(vector)expected type(s)
pin 14requested
invrt_6name
(vector)expected type(s)
pin 15requested
invrt_7name
(vector)expected type(s)
pin 16requested
invrt_8name
(vector)expected type(s)
pin 17requested
dfmffile_pathname
(string)expected type(s)

path with motion dfmf extension where the export occurs

pin 18requested
rstfile_pathname
(string)expected type(s)

Outputs

pin 0requested
dfmf_data_sourcename
(data_sources)expected type(s)

Data Source containing the dfmf file generated.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: write_motion_dfmf_file
  • full name: result.write_motion_dfmf_file
  • internal name: write_motion_dfmf_file
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.write_motion_dfmf_file() # operator instantiation
op.inputs.model_data.Connect(my_model_data)
op.inputs.mode_shapes.Connect(my_mode_shapes)
op.inputs.lumped_mass.Connect(my_lumped_mass)
op.inputs.field_coordinates.Connect(my_field_coordinates)
op.inputs.nod.Connect(my_nod)
op.inputs.used_node_index.Connect(my_used_node_index)
op.inputs.eigenvalue.Connect(my_eigenvalue)
op.inputs.translational_mode_shape.Connect(my_translational_mode_shape)
op.inputs.rotational_mode_shape.Connect(my_rotational_mode_shape)
op.inputs.invrt_1.Connect(my_invrt_1)
op.inputs.invrt_2.Connect(my_invrt_2)
op.inputs.invrt_3.Connect(my_invrt_3)
op.inputs.invrt_4.Connect(my_invrt_4)
op.inputs.invrt_5.Connect(my_invrt_5)
op.inputs.invrt_6.Connect(my_invrt_6)
op.inputs.invrt_7.Connect(my_invrt_7)
op.inputs.invrt_8.Connect(my_invrt_8)
op.inputs.dfmffile_path.Connect(my_dfmffile_path)
op.inputs.rstfile_path.Connect(my_rstfile_path)
my_dfmf_data_source = op.outputs.dfmf_data_source.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.write_motion_dfmf_file() # operator instantiation
op.inputs.model_data.connect(my_model_data)
op.inputs.mode_shapes.connect(my_mode_shapes)
op.inputs.lumped_mass.connect(my_lumped_mass)
op.inputs.field_coordinates.connect(my_field_coordinates)
op.inputs.nod.connect(my_nod)
op.inputs.used_node_index.connect(my_used_node_index)
op.inputs.eigenvalue.connect(my_eigenvalue)
op.inputs.translational_mode_shape.connect(my_translational_mode_shape)
op.inputs.rotational_mode_shape.connect(my_rotational_mode_shape)
op.inputs.invrt_1.connect(my_invrt_1)
op.inputs.invrt_2.connect(my_invrt_2)
op.inputs.invrt_3.connect(my_invrt_3)
op.inputs.invrt_4.connect(my_invrt_4)
op.inputs.invrt_5.connect(my_invrt_5)
op.inputs.invrt_6.connect(my_invrt_6)
op.inputs.invrt_7.connect(my_invrt_7)
op.inputs.invrt_8.connect(my_invrt_8)
op.inputs.dfmffile_path.connect(my_dfmffile_path)
op.inputs.rstfile_path.connect(my_rstfile_path)
my_dfmf_data_source = op.outputs.dfmf_data_source()
#include "dpf_api.h"

ansys::dpf::Operator op("write_motion_dfmf_file"); // operator instantiation
op.connect(0, my_model_data);
op.connect(1, my_mode_shapes);
op.connect(2, my_lumped_mass);
op.connect(3, my_field_coordinates);
op.connect(4, my_nod);
op.connect(5, my_used_node_index);
op.connect(6, my_eigenvalue);
op.connect(7, my_translational_mode_shape);
op.connect(8, my_rotational_mode_shape);
op.connect(9, my_invrt_1);
op.connect(10, my_invrt_2);
op.connect(11, my_invrt_3);
op.connect(12, my_invrt_4);
op.connect(13, my_invrt_5);
op.connect(14, my_invrt_6);
op.connect(15, my_invrt_7);
op.connect(16, my_invrt_8);
op.connect(17, my_dfmffile_path);
op.connect(18, my_rstfile_path);
ansys::dpf::DataSources my_dfmf_data_source = op.getOutput<ansys::dpf::DataSources>(0);

result: split on facet indices

Description

Splits each Field in a FieldsContainer defined on the skin elements of a mesh according to the local facets indices of its corresponding solid element. The output FieldsContainer retains the original labels and adds a 'facet' label, which indicates at which facet of the solid mesh was the original skin element located. The facet ids are according to MAPDL convention. The scoping of the output Fields reflects the element indices in the solid mesh.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Fields container to split, with generic number of labels (e.g. time, zone, complex...), and the Fields of the FieldsContainer will have location Elemental and the Scoping Ids will be the Element Ids on the skin mesh.

pin 1requested
property_field_new_elements_to_oldname
(property_field)expected type(s)

This property field provides, for each new face element ID (in the scoping), the corresponding 3D volume element index (in the data) it has been extracted from. The 3D volume element ID can be found with the element scoping of the input mesh.

pin 2requested
facet_indicesname
(property_field)expected type(s)

This property field gives, for each new face element ID (in the scoping), the corresponding face index on the source 3D volume element. The 3D volume element can be extracted from the previous output.

pin 3requested
volume_meshname
(abstract_meshed_region)expected type(s)

The solid support.

pin 185optional
degenerated_tetsname
(scoping)expected type(s)

Elemental scoping of tet elements. If connected, the tets in the scoping are treated as degenerated tets (SOLID185), and the rest as non-degenerated tets (SOLID285). Pins 185 and 285 are mutually exclusionary (they cannot be connected at the same time), and if none of them is connected, all tets are treated as non-degenerated (SOLID285).

pin 285optional
non_degenerated_tetsname
(scoping)expected type(s)

Elemental scoping of tet elements. If connected, the tets in the scoping are treated as non-degenerated tets (SOLID285), and the rest as degenerated tets (SOLID185). Pins 185 and 285 are mutually exclusionary (they cannot be connected at the same time), and if none of them is connected, all tets are treated as non-degenerated (SOLID285).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Output splitted fields containter

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: mapdl_split_on_facet_indices
  • full name: result.mapdl_split_on_facet_indices
  • internal name: mapdl::split_on_facet_indices
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mapdl_split_on_facet_indices() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.property_field_new_elements_to_old.Connect(my_property_field_new_elements_to_old)
op.inputs.facet_indices.Connect(my_facet_indices)
op.inputs.volume_mesh.Connect(my_volume_mesh)
op.inputs.degenerated_tets.Connect(my_degenerated_tets)
op.inputs.non_degenerated_tets.Connect(my_non_degenerated_tets)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mapdl_split_on_facet_indices() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.property_field_new_elements_to_old.connect(my_property_field_new_elements_to_old)
op.inputs.facet_indices.connect(my_facet_indices)
op.inputs.volume_mesh.connect(my_volume_mesh)
op.inputs.degenerated_tets.connect(my_degenerated_tets)
op.inputs.non_degenerated_tets.connect(my_non_degenerated_tets)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("mapdl::split_on_facet_indices"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_property_field_new_elements_to_old);
op.connect(2, my_facet_indices);
op.connect(3, my_volume_mesh);
op.connect(185, my_degenerated_tets);
op.connect(285, my_non_degenerated_tets);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: split to acmo facet indices

Description

This will retain the already existing labels from the input FC and will change the facet label to now mean ACMO facet indices.Each Field in the input will be split/merged into several Fields, redistributing the data to the appropriate entity.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Fields container to split, with generic number of labels (e.g. time, zone, complex...), 'facet' label is compulsory.The Fields of the FieldsContainer will have location Elemental and the Scoping Ids will be the Element Ids on the skin mesh.

pin 1requested
property_fields_container_element_typesname
(property_fields_container)expected type(s)

It should only have the 'facet' label. For each facet, it stores a PropertyField with the element types of the corresponding elements.The scoping should be the same as the scoping of the corresponding Field in input 0.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Output splitted fields containter

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: mapdl_split_to_acmo_facet_indices
  • full name: result.mapdl_split_to_acmo_facet_indices
  • internal name: mapdl::split_to_acmo_facet_indices
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.mapdl_split_to_acmo_facet_indices() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.property_fields_container_element_types.Connect(my_property_fields_container_element_types)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.mapdl_split_to_acmo_facet_indices() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.property_fields_container_element_types.connect(my_property_fields_container_element_types)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("mapdl::split_to_acmo_facet_indices"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_property_fields_container_element_types);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: enf solution to global cs

Description

read Euler angles on elements from the result file and rotate the fields in the fieldsContainer.

Inputs

pin 2optional
fields_containername
(fields_container)expected type(s)
pin 3optional
streams_containername
(streams_container | stream | class dataProcessing::CRstFileWrapper)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: enf_rotation_by_euler_nodes
  • full name: result.enf_rotation_by_euler_nodes
  • internal name: mapdl::rst::ENF_rotation_by_euler_nodes
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.enf_rotation_by_euler_nodes() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.enf_rotation_by_euler_nodes() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("mapdl::rst::ENF_rotation_by_euler_nodes"); // operator instantiation
op.connect(2, my_fields_container);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: elastic strain solution to global cs

Description

read Euler angles on elements from the result file and rotate the fields in the fieldsContainer.

Inputs

pin 2optional
fields_containername
(fields_container)expected type(s)
pin 3optional
streams_containername
(streams_container | stream | class dataProcessing::CRstFileWrapper)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: elastic_strain_rotation_by_euler_nodes
  • full name: result.elastic_strain_rotation_by_euler_nodes
  • internal name: mapdl::rst::EPEL_rotation_by_euler_nodes
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.elastic_strain_rotation_by_euler_nodes() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.elastic_strain_rotation_by_euler_nodes() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("mapdl::rst::EPEL_rotation_by_euler_nodes"); // operator instantiation
op.connect(2, my_fields_container);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: plastic strain to global cs

Description

read Euler angles on elements from the result file and rotate the fields in the fieldsContainer.

Inputs

pin 2optional
fields_containername
(fields_container)expected type(s)
pin 3optional
streams_containername
(streams_container | stream | class dataProcessing::CRstFileWrapper)expected type(s)
pin 4requested
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mapdl
  • scripting name: plastic_strain_rotation_by_euler_nodes
  • full name: result.plastic_strain_rotation_by_euler_nodes
  • internal name: mapdl::rst::EPPL_rotation_by_euler_nodes
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.plastic_strain_rotation_by_euler_nodes() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.plastic_strain_rotation_by_euler_nodes() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("mapdl::rst::EPPL_rotation_by_euler_nodes"); // operator instantiation
op.connect(2, my_fields_container);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: qr solve

Description

Computes the solution using QR factorization.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

fields_container

pin 1requested
rhsname
(fields_container)expected type(s)

fields_container

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: qr_solve
  • full name: math.qr_solve
  • internal name: qrsolveOp
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.qr_solve() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.rhs.Connect(my_rhs)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.qr_solve() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.rhs.connect(my_rhs)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("qrsolveOp"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_rhs);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: von mises strains as mechanical workflow

Description

Generates a workflow that computes the equivalent (Von Mises) elastic strains and averages it to the nodes (by default). For multibody simulations, averaging across bodies can either be activated or deactivated.

Inputs

pin 0optional
time_scopingname
(scoping | vector)expected type(s)

time/freq (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.

pin 1optional
mesh_scopingname
(scoping | scopings_container)expected type(s)

nodes or elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the results file.

pin 9optional
requested_locationname
(string)expected type(s)

average the elemental nodal result to the requested location (default is nodal).

pin 14optional
read_cyclicname
(bool)expected type(s)

if true, cyclic expansion is done. If false, it's ignored..

pin 200optional
average_across_bodiesname
(bool)expected type(s)

for multibody simulations, the stresses are averaged across bodies if true or not if false (default).

Outputs

pin 0requested
workflowname
(workflow)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mechanical_results
  • scripting name: strain_eqv_as_mechanical_workflow
  • full name: result.strain_eqv_as_mechanical_workflow
  • internal name: strain_eqv_as_mechanical_workflow
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.strain_eqv_as_mechanical_workflow() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.average_across_bodies.Connect(my_average_across_bodies)
my_workflow = op.outputs.workflow.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.strain_eqv_as_mechanical_workflow() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.average_across_bodies.connect(my_average_across_bodies)
my_workflow = op.outputs.workflow()
#include "dpf_api.h"

ansys::dpf::Operator op("strain_eqv_as_mechanical_workflow"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(200, my_average_across_bodies);
ansys::dpf::Workflow my_workflow = op.getOutput<ansys::dpf::Workflow>(0);

mesh: mesh clipper

Description

Clips a volume mesh along an iso value x, and construct the volume mesh defined by v < x.

Inputs

pin 0requested
fieldname
(field)expected type(s)
pin 1requested
iso_valuename
(double)expected type(s)

iso value

pin 2requested
closed_surfacename
(int32)expected type(s)

1: closed surface, 0: iso surface.

pin 3optional
meshname
(abstract_meshed_region)expected type(s)
pin 4requested
slice_surfacesname
(bool)expected type(s)

True: slicing will also take into account shell and skin elements. False: slicing will ignore shell and skin elements. The default is true.

Outputs

pin 0requested
fieldname
(field)expected type(s)
pin 2requested
meshname
(meshed_region)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: mesh_clip
  • full name: mesh.mesh_clip
  • internal name: mesh_clip
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.mesh_clip() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.iso_value.Connect(my_iso_value)
op.inputs.closed_surface.Connect(my_closed_surface)
op.inputs.mesh.Connect(my_mesh)
op.inputs.slice_surfaces.Connect(my_slice_surfaces)
my_field = op.outputs.field.GetData()
my_mesh = op.outputs.mesh.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.mesh_clip() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.iso_value.connect(my_iso_value)
op.inputs.closed_surface.connect(my_closed_surface)
op.inputs.mesh.connect(my_mesh)
op.inputs.slice_surfaces.connect(my_slice_surfaces)
my_field = op.outputs.field()
my_mesh = op.outputs.mesh()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh_clip"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_iso_value);
op.connect(2, my_closed_surface);
op.connect(3, my_mesh);
op.connect(4, my_slice_surfaces);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::MeshedRegion my_mesh = op.getOutput<ansys::dpf::MeshedRegion>(2);

serialization: migrate to vtk

Description

Take an input data sources or streams and convert as much data as possible to vtk.

Inputs

pin 0optional
output_filenamename
(string)expected type(s)
pin 3optional
streams_containername
(streams_container)expected type(s)
pin 4optional
data_sourcesname
(data_sources)expected type(s)

Outputs

pin 0requested
data_sourcesname
(data_sources)expected type(s)

Generated output vtk file

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: vtk
  • scripting name: migrate_file_to_vtk
  • full name: serialization.migrate_file_to_vtk
  • internal name: vtk::migrate_file
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.migrate_file_to_vtk() # operator instantiation
op.inputs.output_filename.Connect(my_output_filename)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
my_data_sources = op.outputs.data_sources.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.migrate_file_to_vtk() # operator instantiation
op.inputs.output_filename.connect(my_output_filename)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
my_data_sources = op.outputs.data_sources()
#include "dpf_api.h"

ansys::dpf::Operator op("vtk::migrate_file"); // operator instantiation
op.connect(0, my_output_filename);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
ansys::dpf::DataSources my_data_sources = op.getOutput<ansys::dpf::DataSources>(0);

mesh: external layer

Description

Extracts the external layer (thick skin) of the mesh (3D elements) in a new meshed region.

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)
pin 1requested
nodes_mesh_scopingname
(scoping)expected type(s)
pin 2requested
elements_mesh_scopingname
(scoping)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: external_layer
  • full name: mesh.external_layer
  • internal name: meshed_external_layer_sector
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.external_layer() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
my_mesh = op.outputs.mesh.GetData()
my_nodes_mesh_scoping = op.outputs.nodes_mesh_scoping.GetData()
my_elements_mesh_scoping = op.outputs.elements_mesh_scoping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.external_layer() # operator instantiation
op.inputs.mesh.connect(my_mesh)
my_mesh = op.outputs.mesh()
my_nodes_mesh_scoping = op.outputs.nodes_mesh_scoping()
my_elements_mesh_scoping = op.outputs.elements_mesh_scoping()
#include "dpf_api.h"

ansys::dpf::Operator op("meshed_external_layer_sector"); // operator instantiation
op.connect(0, my_mesh);
ansys::dpf::MeshedRegion my_mesh = op.getOutput<ansys::dpf::MeshedRegion>(0);
ansys::dpf::Scoping my_nodes_mesh_scoping = op.getOutput<ansys::dpf::Scoping>(1);
ansys::dpf::Scoping my_elements_mesh_scoping = op.getOutput<ansys::dpf::Scoping>(2);

mesh: mesh cutter

Description

Extracts a skin of the mesh in triangles in a new meshed region.

Inputs

pin 0requested
fieldname
(field)expected type(s)

Field containing the values for the iso-surface computation. The mesh can be retrieved from this field's support or through pin 2.

pin 1requested
iso_valuename
(double)expected type(s)

iso value

pin 2requested
closed_surfacename
(int32)expected type(s)

1: closed surface, 0: iso surface.

pin 3optional
meshname
(meshed_region)expected type(s)

Mesh to compute the iso-surface from. Used when not given through the support of the field in pin 0.

pin 4requested
slice_surfacesname
(bool)expected type(s)

True: slicing will also take into account shell and skin elements. False: slicing will ignore shell and skin elements. The default is true.

Outputs

pin 2requested
meshname
(meshed_region)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: mesh_cut
  • full name: mesh.mesh_cut
  • internal name: mesh_cut
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.mesh_cut() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.iso_value.Connect(my_iso_value)
op.inputs.closed_surface.Connect(my_closed_surface)
op.inputs.mesh.Connect(my_mesh)
op.inputs.slice_surfaces.Connect(my_slice_surfaces)
my_mesh = op.outputs.mesh.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.mesh_cut() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.iso_value.connect(my_iso_value)
op.inputs.closed_surface.connect(my_closed_surface)
op.inputs.mesh.connect(my_mesh)
op.inputs.slice_surfaces.connect(my_slice_surfaces)
my_mesh = op.outputs.mesh()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh_cut"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_iso_value);
op.connect(2, my_closed_surface);
op.connect(3, my_mesh);
op.connect(4, my_slice_surfaces);
ansys::dpf::MeshedRegion my_mesh = op.getOutput<ansys::dpf::MeshedRegion>(2);

mesh: mesh plan clipper

Description

Clips a volume mesh along a plane and keeps one side.

Inputs

pin 0requested
mesh_or_fieldname
(abstract_meshed_region | field)expected type(s)
pin 1requested
normalname
(field)expected type(s)

An overall 3D vector that gives the normal direction of the plane.

pin 2requested
originname
(field)expected type(s)

An overall 3D vector that gives a point of the plane.

Outputs

pin 0requested
fieldname
(field)expected type(s)
pin 2requested
meshname
(abstract_meshed_region)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: mesh_plan_clip
  • full name: mesh.mesh_plan_clip
  • internal name: mesh_plan_clip
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.mesh_plan_clip() # operator instantiation
op.inputs.mesh_or_field.Connect(my_mesh_or_field)
op.inputs.normal.Connect(my_normal)
op.inputs.origin.Connect(my_origin)
my_field = op.outputs.field.GetData()
my_mesh = op.outputs.mesh.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.mesh_plan_clip() # operator instantiation
op.inputs.mesh_or_field.connect(my_mesh_or_field)
op.inputs.normal.connect(my_normal)
op.inputs.origin.connect(my_origin)
my_field = op.outputs.field()
my_mesh = op.outputs.mesh()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh_plan_clip"); // operator instantiation
op.connect(0, my_mesh_or_field);
op.connect(1, my_normal);
op.connect(2, my_origin);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::MeshedRegion my_mesh = op.getOutput<ansys::dpf::MeshedRegion>(2);

mesh: mesh_to_graphics

Description

Generate tessellation for input mesh

Inputs

pin 1optional
mesh_scopingname
(scoping)expected type(s)
pin 2optional
node_normalsname
(bool)expected type(s)

average element normals for node normals (default no, use element normals for node normals)

pin 7requested
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
nodesname
(field)expected type(s)

node coordinates

pin 1requested
normalsname
(field)expected type(s)

node normals

pin 2requested
connectivityname
(property_field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: mesh_to_graphics
  • full name: mesh.mesh_to_graphics
  • internal name: mesh_to_graphics
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.mesh_to_graphics() # operator instantiation
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.node_normals.Connect(my_node_normals)
op.inputs.mesh.Connect(my_mesh)
my_nodes = op.outputs.nodes.GetData()
my_normals = op.outputs.normals.GetData()
my_connectivity = op.outputs.connectivity.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.mesh_to_graphics() # operator instantiation
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.node_normals.connect(my_node_normals)
op.inputs.mesh.connect(my_mesh)
my_nodes = op.outputs.nodes()
my_normals = op.outputs.normals()
my_connectivity = op.outputs.connectivity()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh_to_graphics"); // operator instantiation
op.connect(1, my_mesh_scoping);
op.connect(2, my_node_normals);
op.connect(7, my_mesh);
ansys::dpf::Field my_nodes = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::Field my_normals = op.getOutput<ansys::dpf::Field>(1);
ansys::dpf::PropertyField my_connectivity = op.getOutput<ansys::dpf::PropertyField>(2);

mesh: mesh_to_graphics_edges

Description

Generate edges of surface elements for input mesh

Inputs

pin 1optional
mesh_scopingname
(scoping)expected type(s)
pin 6optional
include_mid_nodesname
(bool)expected type(s)
pin 7requested
meshname
(abstract_meshed_region)expected type(s)

Outputs

pin 0requested
nodesname
(field)expected type(s)

node coordinates

pin 2requested
connectivityname
(property_field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: mesh_to_graphics_edges
  • full name: mesh.mesh_to_graphics_edges
  • internal name: mesh_to_graphics_edges
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.mesh_to_graphics_edges() # operator instantiation
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.include_mid_nodes.Connect(my_include_mid_nodes)
op.inputs.mesh.Connect(my_mesh)
my_nodes = op.outputs.nodes.GetData()
my_connectivity = op.outputs.connectivity.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.mesh_to_graphics_edges() # operator instantiation
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.include_mid_nodes.connect(my_include_mid_nodes)
op.inputs.mesh.connect(my_mesh)
my_nodes = op.outputs.nodes()
my_connectivity = op.outputs.connectivity()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh_to_graphics_edges"); // operator instantiation
op.connect(1, my_mesh_scoping);
op.connect(6, my_include_mid_nodes);
op.connect(7, my_mesh);
ansys::dpf::Field my_nodes = op.getOutput<ansys::dpf::Field>(0);
ansys::dpf::PropertyField my_connectivity = op.getOutput<ansys::dpf::PropertyField>(2);

mesh: combine levelset

Description

Takes two level sets and computes their binary union.

Inputs

pin 0requested
fieldAname
(field)expected type(s)
pin 1requested
fieldBname
(field)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: combine_levelset
  • full name: mesh.combine_levelset
  • internal name: levelset::combine
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.combine_levelset() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.combine_levelset() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("levelset::combine"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

mesh: exclude levelset

Description

Takes two level sets and excludes the second one from the first.

Inputs

pin 0requested
fieldAname
(field)expected type(s)
pin 1requested
fieldBname
(field)expected type(s)

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: exclude_levelset
  • full name: mesh.exclude_levelset
  • internal name: levelset::exclude
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.exclude_levelset() # operator instantiation
op.inputs.fieldA.Connect(my_fieldA)
op.inputs.fieldB.Connect(my_fieldB)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.exclude_levelset() # operator instantiation
op.inputs.fieldA.connect(my_fieldA)
op.inputs.fieldB.connect(my_fieldB)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("levelset::exclude"); // operator instantiation
op.connect(0, my_fieldA);
op.connect(1, my_fieldB);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

mesh: make plane levelset

Description

Computes the level set for a plane using coordinates.

Inputs

pin 0requested
coordinatesname
(abstract_meshed_region | field)expected type(s)
pin 1requested
normalname
(field)expected type(s)

An overall 3D vector that gives the normal direction of the plane.

pin 2requested
originname
(field)expected type(s)

An overall 3d vector that gives a point of the plane.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: make_plane_levelset
  • full name: mesh.make_plane_levelset
  • internal name: levelset::make_plane
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.make_plane_levelset() # operator instantiation
op.inputs.coordinates.Connect(my_coordinates)
op.inputs.normal.Connect(my_normal)
op.inputs.origin.Connect(my_origin)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.make_plane_levelset() # operator instantiation
op.inputs.coordinates.connect(my_coordinates)
op.inputs.normal.connect(my_normal)
op.inputs.origin.connect(my_origin)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("levelset::make_plane"); // operator instantiation
op.connect(0, my_coordinates);
op.connect(1, my_normal);
op.connect(2, my_origin);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

mesh: make sphere levelset

Description

Computes the level set for a sphere using coordinates.

Inputs

pin 0requested
coordinatesname
(abstract_meshed_region | field)expected type(s)
pin 1requested
originname
(field)expected type(s)

An overall 3d vector that gives a point of the plane.

pin 2requested
radiusname
(double)expected type(s)

Sphere radius.

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: make_sphere_levelset
  • full name: mesh.make_sphere_levelset
  • internal name: levelset::make_sphere
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.make_sphere_levelset() # operator instantiation
op.inputs.coordinates.Connect(my_coordinates)
op.inputs.origin.Connect(my_origin)
op.inputs.radius.Connect(my_radius)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.make_sphere_levelset() # operator instantiation
op.inputs.coordinates.connect(my_coordinates)
op.inputs.origin.connect(my_origin)
op.inputs.radius.connect(my_radius)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("levelset::make_sphere"); // operator instantiation
op.connect(0, my_coordinates);
op.connect(1, my_origin);
op.connect(2, my_radius);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

mesh: mesh extraction

Description

Take a mesh and a scoping (elemental or nodal) and create a new mesh that contains this selection only.

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)
pin 1requested
mesh_scopingname
(scoping)expected type(s)
pin 2optional
extensionname
(int32)expected type(s)

Number of extension layer

Outputs

pin 0requested
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: mesh_extraction
  • full name: mesh.mesh_extraction
  • internal name: mesh_extraction
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.mesh_extraction() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.extension.Connect(my_extension)
my_abstract_meshed_region = op.outputs.abstract_meshed_region.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.mesh_extraction() # operator instantiation
op.inputs.mesh.connect(my_mesh)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.extension.connect(my_extension)
my_abstract_meshed_region = op.outputs.abstract_meshed_region()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh_extraction"); // operator instantiation
op.connect(0, my_mesh);
op.connect(1, my_mesh_scoping);
op.connect(2, my_extension);
ansys::dpf::MeshedRegion my_abstract_meshed_region = op.getOutput<ansys::dpf::MeshedRegion>(0);

mesh: wireframe

Description

Take a mesh and extracts its sharp edges, using pin 1 value as a threshold angle.

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)
pin 1requested
thresholdname
(double)expected type(s)

angle threshold in radian that will trigger an edge detection.

Outputs

pin 0requested
wireframename
(abstract_meshed_region)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: wireframe
  • full name: mesh.wireframe
  • internal name: wireframe
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.wireframe() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
op.inputs.threshold.Connect(my_threshold)
my_wireframe = op.outputs.wireframe.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.wireframe() # operator instantiation
op.inputs.mesh.connect(my_mesh)
op.inputs.threshold.connect(my_threshold)
my_wireframe = op.outputs.wireframe()
#include "dpf_api.h"

ansys::dpf::Operator op("wireframe"); // operator instantiation
op.connect(0, my_mesh);
op.connect(1, my_threshold);
ansys::dpf::MeshedRegion my_wireframe = op.getOutput<ansys::dpf::MeshedRegion>(0);

mesh: mesh to tetra

Description

Converts 3D meshes of arbitrary 3D element types into a tetrahedral mesh, output at pin (0). Non 3D elements are ignored. Scopings providing the mapping from resulting nodes & elements to their original ID in the input mesh are provided, output pins (1) & (2) respectively.

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)

Mesh with arbitrary element types.

Outputs

pin 0requested
meshname
(meshed_region)expected type(s)

Tetrahedralized mesh.

pin 1requested
node_mappingname
(scoping)expected type(s)

Node mapping.

pin 2requested
element_mappingname
(scoping)expected type(s)

Element mapping.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: mesh_to_tetra
  • full name: mesh.mesh_to_tetra
  • internal name: mesh_to_tetra
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.mesh_to_tetra() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
my_mesh = op.outputs.mesh.GetData()
my_node_mapping = op.outputs.node_mapping.GetData()
my_element_mapping = op.outputs.element_mapping.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.mesh_to_tetra() # operator instantiation
op.inputs.mesh.connect(my_mesh)
my_mesh = op.outputs.mesh()
my_node_mapping = op.outputs.node_mapping()
my_element_mapping = op.outputs.element_mapping()
#include "dpf_api.h"

ansys::dpf::Operator op("mesh_to_tetra"); // operator instantiation
op.connect(0, my_mesh);
ansys::dpf::MeshedRegion my_mesh = op.getOutput<ansys::dpf::MeshedRegion>(0);
ansys::dpf::Scoping my_node_mapping = op.getOutput<ansys::dpf::Scoping>(1);
ansys::dpf::Scoping my_element_mapping = op.getOutput<ansys::dpf::Scoping>(2);

mapping: fft

Description

Computes the Fast Fourier Transform on each component of input Field or each field of input Fields Container (you can use transpose_fields_container to have relevant scoping). Fields are assumed with the same scoping, number of components and representing equally spaced data, ideally resampled to have a 2^n points (prepare_sampling_fft with time_freq_interpolation can help creating these fields). If Complex label is present, Complex to Complex FFT performed otherwise Real to Complex is performed (only half of the coefficient will be returned).

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Field or Fields Container.

pin 3optional
scale_forward_transformname
(double)expected type(s)

Scale for Forward Transform, default is 2/field_num_elementary_data.

pin 4optional
inplacename
(bool)expected type(s)

True if inplace, default is false.

pin 5optional
force_fft_pointsname
(int32)expected type(s)

Explicitely define number of fft points to either rescope or perform zero padding.

pin 6optional
cutoff_frequencyname
(double)expected type(s)

Restrict output frequency up to this cutoff frequency

pin 7optional
scale_right_amplitudename
(bool)expected type(s)

If set to true (default is false), 2/field_num_entities scaling will be applied, to have right amplitude values.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Output Complex Fields Container with labels matching input Fields Container. No supports binded, but prepare_sampling_fft provides it.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mapping
  • plugin: core
  • scripting name: fft
  • full name: mapping.fft
  • internal name: fft
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mapping.fft() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.scale_forward_transform.Connect(my_scale_forward_transform)
op.inputs.inplace.Connect(my_inplace)
op.inputs.force_fft_points.Connect(my_force_fft_points)
op.inputs.cutoff_frequency.Connect(my_cutoff_frequency)
op.inputs.scale_right_amplitude.Connect(my_scale_right_amplitude)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mapping.fft() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.scale_forward_transform.connect(my_scale_forward_transform)
op.inputs.inplace.connect(my_inplace)
op.inputs.force_fft_points.connect(my_force_fft_points)
op.inputs.cutoff_frequency.connect(my_cutoff_frequency)
op.inputs.scale_right_amplitude.connect(my_scale_right_amplitude)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("fft"); // operator instantiation
op.connect(0, my_field);
op.connect(3, my_scale_forward_transform);
op.connect(4, my_inplace);
op.connect(5, my_force_fft_points);
op.connect(6, my_cutoff_frequency);
op.connect(7, my_scale_right_amplitude);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: fft gradient evaluation

Description

Evaluate min max based on the fast fourier transform at a given field, using gradient method for adaptative time step.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
time_scopingname
(scoping)expected type(s)

if specified only the results at these set ids are used

pin 2optional
fs_rationame
(int32)expected type(s)

default value = 20

Outputs

pin 0requested
coefficientsname
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: fft_gradient_eval
  • full name: math.fft_gradient_eval
  • internal name: fft_eval_gr
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.fft_gradient_eval() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.fs_ratio.Connect(my_fs_ratio)
my_coefficients = op.outputs.coefficients.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.fft_gradient_eval() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.fs_ratio.connect(my_fs_ratio)
my_coefficients = op.outputs.coefficients()
#include "dpf_api.h"

ansys::dpf::Operator op("fft_eval_gr"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_time_scoping);
op.connect(2, my_fs_ratio);
ansys::dpf::FieldsContainer my_coefficients = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: fft multi harmonic solution minmax

Description

Evaluate min max fields on multi harmonic solution. min and max fields are calculated based on evaluating a fourier series sum wrt rpms and using the gradient method for adaptive time steping

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1optional
rpm_scopingname
(scoping)expected type(s)

rpm scoping, by default the fourier series sum is evaluated using all the rpms

pin 2optional
fs_rationame
(int32)expected type(s)

field or fields container with only one field is expected

pin 3optional
num_subdivisionsname
(int32)expected type(s)

connect number subdivisions, used for uniform discretization

pin 4optional
max_num_subdivisionsname
(int32)expected type(s)

connect max number subdivisions, used to avoid huge number of sudivisions

pin 5optional
num_cyclesname
(int32)expected type(s)

Number of cycle of the periodic signal (default is 2)

pin 6optional
use_harmonic_zeroname
(bool)expected type(s)

use harmonic zero for first rpm (default is false)

pin 7optional
calculate_time_seriesname
(bool)expected type(s)

calculates time series output (output pin 2), setting it to false enhance performance if only min/max are required (default is true)

pin 8optional
substeps_selectorname
(vector)expected type(s)

substeps to evaluate (frequencies), by default the operator is evaluated using all the available steps

Outputs

pin 0requested
field_minname
(fields_container)expected type(s)
pin 1requested
field_maxname
(fields_container)expected type(s)
pin 2requested
all_fieldsname
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: fft_multi_harmonic_minmax
  • full name: math.fft_multi_harmonic_minmax
  • internal name: fft_multi_harmonic_minmax
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.fft_multi_harmonic_minmax() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
op.inputs.rpm_scoping.Connect(my_rpm_scoping)
op.inputs.fs_ratio.Connect(my_fs_ratio)
op.inputs.num_subdivisions.Connect(my_num_subdivisions)
op.inputs.max_num_subdivisions.Connect(my_max_num_subdivisions)
op.inputs.num_cycles.Connect(my_num_cycles)
op.inputs.use_harmonic_zero.Connect(my_use_harmonic_zero)
op.inputs.calculate_time_series.Connect(my_calculate_time_series)
op.inputs.substeps_selector.Connect(my_substeps_selector)
my_field_min = op.outputs.field_min.GetData()
my_field_max = op.outputs.field_max.GetData()
my_all_fields = op.outputs.all_fields.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.fft_multi_harmonic_minmax() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
op.inputs.rpm_scoping.connect(my_rpm_scoping)
op.inputs.fs_ratio.connect(my_fs_ratio)
op.inputs.num_subdivisions.connect(my_num_subdivisions)
op.inputs.max_num_subdivisions.connect(my_max_num_subdivisions)
op.inputs.num_cycles.connect(my_num_cycles)
op.inputs.use_harmonic_zero.connect(my_use_harmonic_zero)
op.inputs.calculate_time_series.connect(my_calculate_time_series)
op.inputs.substeps_selector.connect(my_substeps_selector)
my_field_min = op.outputs.field_min()
my_field_max = op.outputs.field_max()
my_all_fields = op.outputs.all_fields()
#include "dpf_api.h"

ansys::dpf::Operator op("fft_multi_harmonic_minmax"); // operator instantiation
op.connect(0, my_fields_container);
op.connect(1, my_rpm_scoping);
op.connect(2, my_fs_ratio);
op.connect(3, my_num_subdivisions);
op.connect(4, my_max_num_subdivisions);
op.connect(5, my_num_cycles);
op.connect(6, my_use_harmonic_zero);
op.connect(7, my_calculate_time_series);
op.connect(8, my_substeps_selector);
ansys::dpf::FieldsContainer my_field_min = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_field_max = op.getOutput<ansys::dpf::FieldsContainer>(1);
ansys::dpf::FieldsContainer my_all_fields = op.getOutput<ansys::dpf::FieldsContainer>(2);

math: svd

Description

Computes the matrix singular value decomposition (SVD) for each field in the given fields container.

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

fields_container

Outputs

pin 0requested
s_svdname
(fields_container)expected type(s)

Singular values of the input data, where A=U.S.Vt

pin 1requested
u_svdname
(fields_container)expected type(s)

U of the input data, where A=U.S.Vt

pin 2requested
vt_svdname
(fields_container)expected type(s)

Vt of the input data, where A=U.S.Vt

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: svd
  • full name: math.svd
  • internal name: svdOp
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.svd() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_s_svd = op.outputs.s_svd.GetData()
my_u_svd = op.outputs.u_svd.GetData()
my_vt_svd = op.outputs.vt_svd.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.svd() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_s_svd = op.outputs.s_svd()
my_u_svd = op.outputs.u_svd()
my_vt_svd = op.outputs.vt_svd()
#include "dpf_api.h"

ansys::dpf::Operator op("svdOp"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_s_svd = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_u_svd = op.getOutput<ansys::dpf::FieldsContainer>(1);
ansys::dpf::FieldsContainer my_vt_svd = op.getOutput<ansys::dpf::FieldsContainer>(2);

math: time integration

Description

Integrates a field of time varying quantities over time

Inputs

pin 0requested
fieldname
(field)expected type(s)

field

pin 1optional
resample_outputname
(bool)expected type(s)

Resample the output

pin 2optional
absolute_errorname
(double)expected type(s)

Absolute error for the resampling

pin 3optional
minimum_step_sizename
(double)expected type(s)

Minimum time step size for the resamplig

pin 4optional
integration_constantname
(double)expected type(s)

Constant to be added to the integrated field

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: time_integration
  • full name: math.time_integration
  • internal name: TimeIntegration
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.time_integration() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.resample_output.Connect(my_resample_output)
op.inputs.absolute_error.Connect(my_absolute_error)
op.inputs.minimum_step_size.Connect(my_minimum_step_size)
op.inputs.integration_constant.Connect(my_integration_constant)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.time_integration() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.resample_output.connect(my_resample_output)
op.inputs.absolute_error.connect(my_absolute_error)
op.inputs.minimum_step_size.connect(my_minimum_step_size)
op.inputs.integration_constant.connect(my_integration_constant)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("TimeIntegration"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_resample_output);
op.connect(2, my_absolute_error);
op.connect(3, my_minimum_step_size);
op.connect(4, my_integration_constant);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: time derivation

Description

Derives a field of time varying quantities with respect to time

Inputs

pin 0requested
fieldname
(field)expected type(s)

field

pin 1optional
spline_fittingname
(bool)expected type(s)

Uses spline fitting on the input field to compute smooth derivatives

Outputs

pin 0requested
fieldname
(field)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: time_derivation
  • full name: math.time_derivation
  • internal name: TimeDerivation
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.time_derivation() # operator instantiation
op.inputs.field.Connect(my_field)
op.inputs.spline_fitting.Connect(my_spline_fitting)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.time_derivation() # operator instantiation
op.inputs.field.connect(my_field)
op.inputs.spline_fitting.connect(my_spline_fitting)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("TimeDerivation"); // operator instantiation
op.connect(0, my_field);
op.connect(1, my_spline_fitting);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

mapping: prep sampling fft

Description

Prepare time sampling optimum for FFT computation and expected frequencies in output.

Inputs

pin 0requested
time_freq_supportname
(time_freq_support)expected type(s)

Initial time domain TimeFreqSupport.

pin 1optional
cutoff_frequencyname
(double)expected type(s)

Cutoff Frequency. In this case, number of points is calculated computing (time_range * cutoff_freq * 2) and taking the next power of 2 (optimum for fft calculation).

pin 2optional
number_sampling_pointname
(int32)expected type(s)

For number of sampling point (calculation with cutoff_frequency is ignored).

Outputs

pin 0requested
time_tfs_sampledname
(time_freq_support)expected type(s)

Optimum sampled time domain TimeFreqSupport.

pin 1requested
freq_tfs_fftname
(time_freq_support)expected type(s)

Frequency domain TimeFreqSupport expected in output of FFT.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mapping
  • plugin: core
  • scripting name: prep_sampling_fft
  • full name: mapping.prep_sampling_fft
  • internal name: prepare_sampling_fft
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mapping.prep_sampling_fft() # operator instantiation
op.inputs.time_freq_support.Connect(my_time_freq_support)
op.inputs.cutoff_frequency.Connect(my_cutoff_frequency)
op.inputs.number_sampling_point.Connect(my_number_sampling_point)
my_time_tfs_sampled = op.outputs.time_tfs_sampled.GetData()
my_freq_tfs_fft = op.outputs.freq_tfs_fft.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mapping.prep_sampling_fft() # operator instantiation
op.inputs.time_freq_support.connect(my_time_freq_support)
op.inputs.cutoff_frequency.connect(my_cutoff_frequency)
op.inputs.number_sampling_point.connect(my_number_sampling_point)
my_time_tfs_sampled = op.outputs.time_tfs_sampled()
my_freq_tfs_fft = op.outputs.freq_tfs_fft()
#include "dpf_api.h"

ansys::dpf::Operator op("prepare_sampling_fft"); // operator instantiation
op.connect(0, my_time_freq_support);
op.connect(1, my_cutoff_frequency);
op.connect(2, my_number_sampling_point);
ansys::dpf::TimeFreqSupport my_time_tfs_sampled = op.getOutput<ansys::dpf::TimeFreqSupport>(0);
ansys::dpf::TimeFreqSupport my_freq_tfs_fft = op.getOutput<ansys::dpf::TimeFreqSupport>(1);

math: fft filtering and cubic fitting

Description

Computes the fitting curve using FFT filtering and cubic fitting in space (node i: x=time, y=data), with the possibility to compute the first and the second derivatives of the curve.

Inputs

pin 0optional
time_scopingname
(vector | scoping)expected type(s)

A time scoping to rescope / split the fields container given as input.

pin 1optional
mesh_scopingname
(umap | scoping | scopings_container)expected type(s)

A space (mesh entities) scoping (or scopings container) to rescope / split the fields container given as input.

pin 2requested
entity_to_fitname
(fields_container)expected type(s)

Data changing in time to be fitted.

pin 3requested
component_numbername
(int32)expected type(s)

Component number as an integer, for example '0' for X-displacement, '1' for Y-displacement, and so on.

pin 4requested
first_derivativename
(bool)expected type(s)

Calculate the first derivative (bool). The default is false.

pin 5requested
second_derivativename
(bool)expected type(s)

Calculate the second derivative (bool). The default is false.

pin 6requested
fit_dataname
(bool)expected type(s)

Calculate the fitted values (bool). The default is false

pin 7optional
cutoff_frname
(double | int32)expected type(s)

Cutoff frequency.

Outputs

pin 0requested
fitted_entity_yname
(fields_container)expected type(s)

The fitted entity is fitted using FFT along the space scoping (node i: x=time, y=data). Fitted Y is expected to be close to the input data.

pin 1requested
first_der_dyname
(fields_container)expected type(s)

The first derivative (dY) from the fitted Y.

pin 2requested
second_der_d2yname
(fields_container)expected type(s)

The second derivative (d2Y) from the fitted Y.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: math
  • plugin: core
  • scripting name: fft_approx
  • full name: math.fft_approx
  • internal name: fft_approx
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.fft_approx() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.entity_to_fit.Connect(my_entity_to_fit)
op.inputs.component_number.Connect(my_component_number)
op.inputs.first_derivative.Connect(my_first_derivative)
op.inputs.second_derivative.Connect(my_second_derivative)
op.inputs.fit_data.Connect(my_fit_data)
op.inputs.cutoff_fr.Connect(my_cutoff_fr)
my_fitted_entity_y = op.outputs.fitted_entity_y.GetData()
my_first_der_dy = op.outputs.first_der_dy.GetData()
my_second_der_d2y = op.outputs.second_der_d2y.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.fft_approx() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.entity_to_fit.connect(my_entity_to_fit)
op.inputs.component_number.connect(my_component_number)
op.inputs.first_derivative.connect(my_first_derivative)
op.inputs.second_derivative.connect(my_second_derivative)
op.inputs.fit_data.connect(my_fit_data)
op.inputs.cutoff_fr.connect(my_cutoff_fr)
my_fitted_entity_y = op.outputs.fitted_entity_y()
my_first_der_dy = op.outputs.first_der_dy()
my_second_der_d2y = op.outputs.second_der_d2y()
#include "dpf_api.h"

ansys::dpf::Operator op("fft_approx"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(2, my_entity_to_fit);
op.connect(3, my_component_number);
op.connect(4, my_first_derivative);
op.connect(5, my_second_derivative);
op.connect(6, my_fit_data);
op.connect(7, my_cutoff_fr);
ansys::dpf::FieldsContainer my_fitted_entity_y = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_first_der_dy = op.getOutput<ansys::dpf::FieldsContainer>(1);
ansys::dpf::FieldsContainer my_second_der_d2y = op.getOutput<ansys::dpf::FieldsContainer>(2);

math: window triangular

Description

Apply triangular windowing on a given FieldsContainer having time label or a Field located on time. Assume that time sampling is evenly spaced (use time_freq_interpolation before otherwise).

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Outputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: window_triangular
  • full name: math.window_triangular
  • internal name: window::triangular
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.window_triangular() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.window_triangular() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("window::triangular"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: window hanning

Description

Apply hanning windowing on a given FieldsContainer having time label or a Field located on time. Assume that time sampling is evenly spaced (use time_freq_interpolation before otherwise).

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Outputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: window_hanning
  • full name: math.window_hanning
  • internal name: window::hanning
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.window_hanning() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.window_hanning() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("window::hanning"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: window hamming

Description

Apply hamming windowing on a given FieldsContainer having time label or a Field located on time. Assume that time sampling is evenly spaced (use time_freq_interpolation before otherwise).

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Outputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: window_hamming
  • full name: math.window_hamming
  • internal name: window::hamming
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.window_hamming() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.window_hamming() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("window::hamming"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: window welch

Description

Apply welch windowing on a given FieldsContainer having time label or a Field located on time. Assume that time sampling is evenly spaced (use time_freq_interpolation before otherwise).

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Outputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: window_welch
  • full name: math.window_welch
  • internal name: window::welch
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.window_welch() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.window_welch() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("window::welch"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: window blackman

Description

Apply blackman windowing on a given FieldsContainer having time label or a Field located on time. Assume that time sampling is evenly spaced (use time_freq_interpolation before otherwise).

Inputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Outputs

pin 0requested
fieldname
(field | fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: window_blackman
  • full name: math.window_blackman
  • internal name: window::blackman
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.window_blackman() # operator instantiation
op.inputs.field.Connect(my_field)
my_field = op.outputs.field.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.window_blackman() # operator instantiation
op.inputs.field.connect(my_field)
my_field = op.outputs.field()
#include "dpf_api.h"

ansys::dpf::Operator op("window::blackman"); // operator instantiation
op.connect(0, my_field);
ansys::dpf::Field my_field = op.getOutput<ansys::dpf::Field>(0);

math: window triangular (fields container)

Description

Apply triangular windowing on a given FieldsContainer having time label or a Field located on time. Assume that time sampling is evenly spaced (use time_freq_interpolation before otherwise).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: window_triangular_fc
  • full name: math.window_triangular_fc
  • internal name: window::triangular_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.window_triangular_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.window_triangular_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("window::triangular_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: window hanning (fields container)

Description

Apply hanning windowing on a given FieldsContainer having time label or a Field located on time. Assume that time sampling is evenly spaced (use time_freq_interpolation before otherwise).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: window_hanning_fc
  • full name: math.window_hanning_fc
  • internal name: window::hanning_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.window_hanning_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.window_hanning_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("window::hanning_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: window hamming (fields container)

Description

Apply hamming windowing on a given FieldsContainer having time label or a Field located on time. Assume that time sampling is evenly spaced (use time_freq_interpolation before otherwise).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: window_hamming_fc
  • full name: math.window_hamming_fc
  • internal name: window::hamming_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.window_hamming_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.window_hamming_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("window::hamming_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: window welch (fields container)

Description

Apply welch windowing on a given FieldsContainer having time label or a Field located on time. Assume that time sampling is evenly spaced (use time_freq_interpolation before otherwise).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: window_welch_fc
  • full name: math.window_welch_fc
  • internal name: window::welch_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.window_welch_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.window_welch_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("window::welch_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: window blackman (fields container)

Description

Apply blackman windowing on a given FieldsContainer having time label or a Field located on time. Assume that time sampling is evenly spaced (use time_freq_interpolation before otherwise).

Inputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: math
  • plugin: core
  • scripting name: window_blackman_fc
  • full name: math.window_blackman_fc
  • internal name: window::blackman_fc
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.window_blackman_fc() # operator instantiation
op.inputs.fields_container.Connect(my_fields_container)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.window_blackman_fc() # operator instantiation
op.inputs.fields_container.connect(my_fields_container)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("window::blackman_fc"); // operator instantiation
op.connect(0, my_fields_container);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

math: expansion psd

Description

Computes the PSD response for one-sigma solution.

Inputs

pin 0requested
mode_shapesname
(fields_container)expected type(s)

Fields container containing the mode shapes from modal analysis file: mode shapes for dynamic and pseudo-static displacements

pin 1optional
static_shapesname
(fields_container)expected type(s)

Fields container containing the static shapes (base excitations) from spectral analysis file

pin 2requested
rel_rel_covar_matrixname
(fields_container)expected type(s)

Fields container containing covariance matrices from a psd file: covariance matrix terms for displacement/velocity/acceleration mode-mode shapes

pin 3optional
stat_stat_covar_matrixname
(fields_container)expected type(s)

Fields container containing covariance matrices from a psd file: covariance matrix terms for displacement/velocity/acceleration static-static shapes

pin 4optional
rel_stat_covar_matrixname
(fields_container)expected type(s)

Fields container containing covariance matrices from a psd file: covariance matrix terms for displacement/velocity/acceleration mode-static shapes

Outputs

pin 0requested
psdname
(fields_container)expected type(s)

PSD solution per label

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: math
  • plugin: core
  • scripting name: expansion_psd
  • full name: math.expansion_psd
  • internal name: expansion::psd
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.math.expansion_psd() # operator instantiation
op.inputs.mode_shapes.Connect(my_mode_shapes)
op.inputs.static_shapes.Connect(my_static_shapes)
op.inputs.rel_rel_covar_matrix.Connect(my_rel_rel_covar_matrix)
op.inputs.stat_stat_covar_matrix.Connect(my_stat_stat_covar_matrix)
op.inputs.rel_stat_covar_matrix.Connect(my_rel_stat_covar_matrix)
my_psd = op.outputs.psd.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.math.expansion_psd() # operator instantiation
op.inputs.mode_shapes.connect(my_mode_shapes)
op.inputs.static_shapes.connect(my_static_shapes)
op.inputs.rel_rel_covar_matrix.connect(my_rel_rel_covar_matrix)
op.inputs.stat_stat_covar_matrix.connect(my_stat_stat_covar_matrix)
op.inputs.rel_stat_covar_matrix.connect(my_rel_stat_covar_matrix)
my_psd = op.outputs.psd()
#include "dpf_api.h"

ansys::dpf::Operator op("expansion::psd"); // operator instantiation
op.connect(0, my_mode_shapes);
op.connect(1, my_static_shapes);
op.connect(2, my_rel_rel_covar_matrix);
op.connect(3, my_stat_stat_covar_matrix);
op.connect(4, my_rel_stat_covar_matrix);
ansys::dpf::FieldsContainer my_psd = op.getOutput<ansys::dpf::FieldsContainer>(0);

serialization: hdf5dpf generate result file

Description

Generate a dpf result file from provided information.

Inputs

pin -6optional
append_modename
(bool)expected type(s)

Experimental: Allow appending chunked data to the file. This disables fields container content deduplication.

pin -5optional
dataset_size_compression_thresholdname
(int32)expected type(s)

Integer value that defines the minimum dataset size (in bytes) to use h5 native compression Applicable for arrays of floats, doubles and integers.

pin -2optional
h5_native_compressionname
(int32 | abstract_data_tree)expected type(s)

Integer value / DataTree that defines the h5 native compression used For Integer Input {0: No Compression (default); 1-9: GZIP Compression : 9 provides maximum compression but at the slowest speed.}For DataTree Input {type: None / GZIP / ZSTD; level: GZIP (1-9) / ZSTD (1-20); num_threads: ZSTD (>0)}

pin -1optional
export_floatsname
(bool)expected type(s)

converts double to float to reduce file size (default is true)

pin 0requested
filenamename
(string)expected type(s)

name of the output file that will be generated (utf8).

pin 1optional
mesh_provider_outname
(abstract_meshed_region)expected type(s)

defines the MeshedRegion that is exported and provided by MeshProvider.

pin 2optional
time_freq_support_outname
(time_freq_support)expected type(s)

defines the TimeFreqSupport that is exported and provided by TimeFreqSupportProvider.

pin 3optional
ansys_unit_system_idname
(int32 | result_info)expected type(s)

defines the unit system the results are exported with. A Result info can be input to also export Physics Type and Analysis Type.

pin 4, 5...optional, ellipsis
input_namename
(string | any)expected type(s)

Set of even and odd pins to serialize results. Odd pins (4, 6, 8...) are strings, and they represent the names of the results to be serialized. Even pins (5, 7, 9...) are DPF types, and they represent the results to be serialized. They should go in pairs (for each result name, there should be a result) and connected sequentially.

Outputs

pin 0requested
data_sourcesname
(data_sources)expected type(s)

data_sources filled with the H5 generated file path.

Configurations

evaluate_inputs_before_runIf this option is set to true, all input pins of the operator will be evaluated before entering the run method to maintain a correct Operator status.
(bool)expected type(s)
falsedefault value
: If this option is set to true, all input pins of the operator will be evaluated before entering the run method to maintain a correct Operator status.
mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: serialization
  • plugin: core
  • scripting name: hdf5dpf_generate_result_file
  • full name: serialization.hdf5dpf_generate_result_file
  • internal name: hdf5::h5dpf::make_result_file
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.hdf5dpf_generate_result_file() # operator instantiation
op.inputs.append_mode.Connect(my_append_mode)
op.inputs.dataset_size_compression_threshold.Connect(my_dataset_size_compression_threshold)
op.inputs.h5_native_compression.Connect(my_h5_native_compression)
op.inputs.export_floats.Connect(my_export_floats)
op.inputs.filename.Connect(my_filename)
op.inputs.mesh_provider_out.Connect(my_mesh_provider_out)
op.inputs.time_freq_support_out.Connect(my_time_freq_support_out)
op.inputs.ansys_unit_system_id.Connect(my_ansys_unit_system_id)
op.inputs.input_name1.Connect(my_input_name_1)
op.inputs.input_name2.Connect(my_input_name_2)
my_data_sources = op.outputs.data_sources.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.hdf5dpf_generate_result_file() # operator instantiation
op.inputs.append_mode.connect(my_append_mode)
op.inputs.dataset_size_compression_threshold.connect(my_dataset_size_compression_threshold)
op.inputs.h5_native_compression.connect(my_h5_native_compression)
op.inputs.export_floats.connect(my_export_floats)
op.inputs.filename.connect(my_filename)
op.inputs.mesh_provider_out.connect(my_mesh_provider_out)
op.inputs.time_freq_support_out.connect(my_time_freq_support_out)
op.inputs.ansys_unit_system_id.connect(my_ansys_unit_system_id)
op.inputs.input_name1.connect(my_input_name_1)
op.inputs.input_name2.connect(my_input_name_2)
my_data_sources = op.outputs.data_sources()
#include "dpf_api.h"

ansys::dpf::Operator op("hdf5::h5dpf::make_result_file"); // operator instantiation
op.connect(-6, my_append_mode);
op.connect(-5, my_dataset_size_compression_threshold);
op.connect(-2, my_h5_native_compression);
op.connect(-1, my_export_floats);
op.connect(0, my_filename);
op.connect(1, my_mesh_provider_out);
op.connect(2, my_time_freq_support_out);
op.connect(3, my_ansys_unit_system_id);
op.connect(4, my_input_name_1);
op.connect(5, my_input_name_2);
ansys::dpf::DataSources my_data_sources = op.getOutput<ansys::dpf::DataSources>(0);

result: migrate to h5dpf

Description

Read mesh properties from the results files contained in the streams or data sources and make those properties available through a mesh selection manager in output.User can input a GenericDataContainer that will map an item to a result name. Example of Map: {{ default: wf1}, {EUL: wf2}, {ENG_SE: wf3}}.

Inputs

pin -5optional
dataset_size_compression_thresholdname
(int32 | generic_data_container)expected type(s)

Integer value that defines the minimum dataset size (in bytes) to use h5 native compression Applicable for arrays of floats, doubles and integers.

pin -2optional
h5_native_compressionname
(int32 | abstract_data_tree | generic_data_container)expected type(s)

Integer value / DataTree that defines the h5 native compression used For Integer Input {0: No Compression (default); 1-9: GZIP Compression : 9 provides maximum compression but at the slowest speed.}For DataTree Input {type: None / GZIP / ZSTD; level: GZIP (1-9) / ZSTD (1-20); num_threads: ZSTD (>0)}

pin -1optional
export_floatsname
(bool | generic_data_container)expected type(s)

Converts double to float to reduce file size (default is true).If False, nodal results are exported as double precision and elemental results as single precision.

pin 0requested
filenamename
(string)expected type(s)

filename of the migrated file

pin 1optional
comma_separated_list_of_resultsname
(string)expected type(s)

list of results (source operator names) separated by semicolons that will be stored. (Example: U;S;EPEL). If empty, all available results will be converted.

pin 2optional
all_time_setsname
(bool)expected type(s)

Deprecated. Please use filtering workflows instead to select time scoping. Default is false.

pin 3optional
streams_containername
(streams_container)expected type(s)

streams (result file container) (optional)

pin 4optional
data_sourcesname
(data_sources)expected type(s)

if the stream is null then we need to get the file path from the data sources

pin 6optional
compression_workflowname
(workflow | generic_data_container)expected type(s)

BETA Option: Applies input compression workflow.

pin 7optional
filtering_workflowname
(workflow | generic_data_container)expected type(s)

Applies input filtering workflow.

Outputs

pin 0requested
migrated_filename
(data_sources)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: core
  • scripting name: migrate_to_h5dpf
  • full name: result.migrate_to_h5dpf
  • internal name: hdf5::h5dpf::migrate_file
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.migrate_to_h5dpf() # operator instantiation
op.inputs.dataset_size_compression_threshold.Connect(my_dataset_size_compression_threshold)
op.inputs.h5_native_compression.Connect(my_h5_native_compression)
op.inputs.export_floats.Connect(my_export_floats)
op.inputs.filename.Connect(my_filename)
op.inputs.comma_separated_list_of_results.Connect(my_comma_separated_list_of_results)
op.inputs.all_time_sets.Connect(my_all_time_sets)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.compression_workflow.Connect(my_compression_workflow)
op.inputs.filtering_workflow.Connect(my_filtering_workflow)
my_migrated_file = op.outputs.migrated_file.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.migrate_to_h5dpf() # operator instantiation
op.inputs.dataset_size_compression_threshold.connect(my_dataset_size_compression_threshold)
op.inputs.h5_native_compression.connect(my_h5_native_compression)
op.inputs.export_floats.connect(my_export_floats)
op.inputs.filename.connect(my_filename)
op.inputs.comma_separated_list_of_results.connect(my_comma_separated_list_of_results)
op.inputs.all_time_sets.connect(my_all_time_sets)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.compression_workflow.connect(my_compression_workflow)
op.inputs.filtering_workflow.connect(my_filtering_workflow)
my_migrated_file = op.outputs.migrated_file()
#include "dpf_api.h"

ansys::dpf::Operator op("hdf5::h5dpf::migrate_file"); // operator instantiation
op.connect(-5, my_dataset_size_compression_threshold);
op.connect(-2, my_h5_native_compression);
op.connect(-1, my_export_floats);
op.connect(0, my_filename);
op.connect(1, my_comma_separated_list_of_results);
op.connect(2, my_all_time_sets);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(6, my_compression_workflow);
op.connect(7, my_filtering_workflow);
ansys::dpf::DataSources my_migrated_file = op.getOutput<ansys::dpf::DataSources>(0);

result: von mises stresses as mechanical workflow

Description

Generates a workflow that computes the equivalent (Von Mises) stresses and averages it to the nodes (by default). For multibody simulations, averaging across bodies can either be activated or deactivated.

Inputs

pin 0optional
time_scopingname
(scoping | vector)expected type(s)

time/freq (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.

pin 1optional
mesh_scopingname
(scoping | scopings_container)expected type(s)

nodes or elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the results file.

pin 9optional
requested_locationname
(string)expected type(s)

average the elemental nodal result to the requested location (default is nodal).

pin 14optional
read_cyclicname
(bool)expected type(s)

if true, cyclic expansion is done. If false, it's ignored..

pin 200optional
average_across_bodiesname
(bool)expected type(s)

for multibody simulations, the stresses are averaged across bodies if true or not if false (default).

Outputs

pin 0requested
workflowname
(workflow)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mechanical_results
  • scripting name: stress_eqv_as_mechanical_workflow
  • full name: result.stress_eqv_as_mechanical_workflow
  • internal name: stress_eqv_as_mechanical_workflow
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.stress_eqv_as_mechanical_workflow() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.average_across_bodies.Connect(my_average_across_bodies)
my_workflow = op.outputs.workflow.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.stress_eqv_as_mechanical_workflow() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.average_across_bodies.connect(my_average_across_bodies)
my_workflow = op.outputs.workflow()
#include "dpf_api.h"

ansys::dpf::Operator op("stress_eqv_as_mechanical_workflow"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(14, my_read_cyclic);
op.connect(200, my_average_across_bodies);
ansys::dpf::Workflow my_workflow = op.getOutput<ansys::dpf::Workflow>(0);

utility: hdf5dpf workflow provider

Description

Extract a custom result from an hdf5dpf file as an executable workflow.

Inputs

pin 0optional
time_scopingname
(scoping)expected type(s)
pin 1optional
mesh_scopingname
(scoping)expected type(s)
pin 3optional
streamsname
(streams_container)expected type(s)

Hdf5df file stream.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

Hdf5df file data source.

pin 24optional
meta_dataname
(abstract_data_tree)expected type(s)

meta_data that may be used to evaluate results or extract workflows.

pin 60requested
result_namename

Name of the result that must be extracted from the hdf5dpf file

Outputs

pin 0requested
field_or_fields_containername
(workflow)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: utility
  • plugin: core
  • scripting name: hdf5dpf_workglow_provider
  • full name: utility.hdf5dpf_workglow_provider
  • internal name: hdf5::h5dpf::workflow_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.utility.hdf5dpf_workglow_provider() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams.Connect(my_streams)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.meta_data.Connect(my_meta_data)
op.inputs.result_name.Connect(my_result_name)
my_field_or_fields_container = op.outputs.field_or_fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.utility.hdf5dpf_workglow_provider() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams.connect(my_streams)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.meta_data.connect(my_meta_data)
op.inputs.result_name.connect(my_result_name)
my_field_or_fields_container = op.outputs.field_or_fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("hdf5::h5dpf::workflow_provider"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams);
op.connect(4, my_data_sources);
op.connect(24, my_meta_data);
op.connect(60, my_result_name);
ansys::dpf::Workflow my_field_or_fields_container = op.getOutput<ansys::dpf::Workflow>(0);

other: hdf5dpf mesh property provider

Description

Reads a property related to the mesh, defined by its name, by calling the readers defined by the data sources. These properties can be used to fill in the mesh.

Inputs

pin 1optional
mesh_scopingname
(scoping)expected type(s)

Retrieves a property field on a subset of elements or nodes.

pin 3optional
streams_containername
(streams_container)expected type(s)

streams (result file container) (optional)

pin 4requested
data_sourcesname
(data_sources)expected type(s)

If the stream is null, retrieves the file path from the data sources.

pin 13requested
property_namename
(string)expected type(s)

Supported property names are: "mat", "named_selection", "named_selection_names", "apdl_element_type", "section", "elprops", "keyopt_1" to "keyopt_18".

pin 17optional
property_identifiername
(int32 | string)expected type(s)

Retrieves a property at a given index or by name. For example, a named selection's number or a named selection's name.

Outputs

pin 0requested
propertyname
(scoping | property_field | string_field)expected type(s)

Returns a property field for properties: "mat", "apdl_element_type", "section", "elprops", "keyopt_1" to "keyopt_18" (or any mesh's property field), a scoping for properties:"named_selection", a string field for properties: "named_selection_names".

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: other
  • plugin: core
  • scripting name: hdf5dpf_mesh_property_provider
  • full name: other.hdf5dpf_mesh_property_provider
  • internal name: hdf5::h5dpf::mesh_property_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.other.hdf5dpf_mesh_property_provider() # operator instantiation
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.property_name.Connect(my_property_name)
op.inputs.property_identifier.Connect(my_property_identifier)
my_property = op.outputs.property.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.other.hdf5dpf_mesh_property_provider() # operator instantiation
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.property_name.connect(my_property_name)
op.inputs.property_identifier.connect(my_property_identifier)
my_property = op.outputs.property()
#include "dpf_api.h"

ansys::dpf::Operator op("hdf5::h5dpf::mesh_property_provider"); // operator instantiation
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(13, my_property_name);
op.connect(17, my_property_identifier);
ansys::dpf::Scoping my_property = op.getOutput<ansys::dpf::Scoping>(0);

serialization: migrate to vtu

Description

Extract all results from a datasources and exports them into vtu format. All the connected inputs are forwarded to the result providers operators.

Inputs

pin 0optional
time_scopingname
(scoping | vector)expected type(s)

time sets to export, default is all

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container, used if no streams are set

pin 20requested
directoryname
(string)expected type(s)

directory path

pin 21optional
base_namename
(string)expected type(s)

vtu base file name, (default is file)

pin 30, 31...optional, ellipsis
resultname
(string)expected type(s)

if Operator's names are connected to this Pin, only these results are exported (else all available results are exported)

pin 100optional
write_modename
(string)expected type(s)

Available are rawbinarycompressed, rawbinary, base64appended, base64inline, ascii, default is (rawbinarycompressed)

Outputs

pin 0requested
pathname
(data_sources)expected type(s)

list of output vtu file path

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
permissiveIf this option is set to true, warning checks (like unit or data sizes) won't be done.
(bool)expected type(s)
truedefault value
: If this option is set to true, warning checks (like unit or data sizes) won't be done.

Scripting

  • category: serialization
  • plugin: vtk
  • scripting name: migrate_to_vtu
  • full name: serialization.migrate_to_vtu
  • internal name: migrate_to_vtu
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.serialization.migrate_to_vtu() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.directory.Connect(my_directory)
op.inputs.base_name.Connect(my_base_name)
op.inputs.result1.Connect(my_result_1)
op.inputs.result2.Connect(my_result_2)
op.inputs.write_mode.Connect(my_write_mode)
my_path = op.outputs.path.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.serialization.migrate_to_vtu() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.directory.connect(my_directory)
op.inputs.base_name.connect(my_base_name)
op.inputs.result1.connect(my_result_1)
op.inputs.result2.connect(my_result_2)
op.inputs.write_mode.connect(my_write_mode)
my_path = op.outputs.path()
#include "dpf_api.h"

ansys::dpf::Operator op("migrate_to_vtu"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(20, my_directory);
op.connect(21, my_base_name);
op.connect(30, my_result_1);
op.connect(31, my_result_2);
op.connect(100, my_write_mode);
ansys::dpf::DataSources my_path = op.getOutput<ansys::dpf::DataSources>(0);

result: compute total strain Y

Description

Computes the strain from a displacement field. Only SOLID185 (B-Bar, Simplified Enhanced Strain, Enhanced Strain formulations), SOLID186 (Full Integration) & SOLID187 elements are supported. Layered elements are not supported. Thermal strains are not supported. Only one value of material properties are allowed per element for isotropic and orthotropic elasticity. Material nonlinearity is not supported 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 YY normal component (11 component).

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.. Will only be used if no displacement input is given (will be applied on displacement operator).

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Optional if a mesh or a data_sources have been connected. Required if no displacement input have been connected.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Optional if a mesh or a streams_container have been connected, or if the displacement's field has a mesh support. Required if no displacement input have been connected.

pin 5optional
extrapolatename
(int32)expected type(s)

Whether to extrapolate the data from the integration points to the nodes.

pin 6optional
nonlinearname
(int32)expected type(s)

Whether to use nonlinear geometry or nonlinear material (1 = large strain, 2 = hyperelasticity).

pin 7optional
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

The underlying mesh. Optional if a data_sources or a streams_container have been connected, or if the displacement's field has a mesh support.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10optional
displacementname
(fields_container | field)expected type(s)

Field/or fields container containing only the displacement field (nodal). If none specified, read displacements from result file using the data_sources.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_total_strain_Y
  • full name: result.compute_total_strain_Y
  • internal name: compute_total_strain_Y
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_total_strain_Y() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.extrapolate.Connect(my_extrapolate)
op.inputs.nonlinear.Connect(my_nonlinear)
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.displacement.Connect(my_displacement)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_total_strain_Y() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.extrapolate.connect(my_extrapolate)
op.inputs.nonlinear.connect(my_nonlinear)
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.displacement.connect(my_displacement)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_total_strain_Y"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_extrapolate);
op.connect(6, my_nonlinear);
op.connect(7, my_abstract_meshed_region);
op.connect(9, my_requested_location);
op.connect(10, my_displacement);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute stress 2

Description

Computes the stress from an elastic strain field. compute_total_strain limitations are applicable for stress computation Get the 2nd principal component.

Inputs

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Needed to get mesh and material ids. Optional if a data_sources have been connected.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

Needed to get mesh and material ids. Optional if a streams_container have been connected.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10requested
strainname
(fields_container | field)expected type(s)

Field/or fields container containing only the elastic strain field (element nodal).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_stress_2
  • full name: result.compute_stress_2
  • internal name: compute_stress_2
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_stress_2() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.strain.Connect(my_strain)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_stress_2() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.strain.connect(my_strain)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_stress_2"); // operator instantiation
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(9, my_requested_location);
op.connect(10, my_strain);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute total strain

Description

Computes the strain from a displacement field. Only SOLID185 (B-Bar, Simplified Enhanced Strain, Enhanced Strain formulations), SOLID186 (Full Integration) & SOLID187 elements are supported. Layered elements are not supported. Thermal strains are not supported. Only one value of material properties are allowed per element for isotropic and orthotropic elasticity. Material nonlinearity is not supported Only linear analysis are supported without On Demand Expansion. All coordinates are global coordinates. Euler Angles need to be included in the database.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.. Will only be used if no displacement input is given (will be applied on displacement operator).

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Optional if a mesh or a data_sources have been connected. Required if no displacement input have been connected.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Optional if a mesh or a streams_container have been connected, or if the displacement's field has a mesh support. Required if no displacement input have been connected.

pin 5optional
extrapolatename
(int32)expected type(s)

Whether to extrapolate the data from the integration points to the nodes.

pin 6optional
nonlinearname
(int32)expected type(s)

Whether to use nonlinear geometry or nonlinear material (1 = large strain, 2 = hyperelasticity).

pin 7optional
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

The underlying mesh. Optional if a data_sources or a streams_container have been connected, or if the displacement's field has a mesh support.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10optional
displacementname
(fields_container | field)expected type(s)

Field/or fields container containing only the displacement field (nodal). If none specified, read displacements from result file using the data_sources.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_total_strain
  • full name: result.compute_total_strain
  • internal name: compute_total_strain
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_total_strain() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.extrapolate.Connect(my_extrapolate)
op.inputs.nonlinear.Connect(my_nonlinear)
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.displacement.Connect(my_displacement)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_total_strain() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.extrapolate.connect(my_extrapolate)
op.inputs.nonlinear.connect(my_nonlinear)
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.displacement.connect(my_displacement)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_total_strain"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_extrapolate);
op.connect(6, my_nonlinear);
op.connect(7, my_abstract_meshed_region);
op.connect(9, my_requested_location);
op.connect(10, my_displacement);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute total strain XY

Description

Computes the strain from a displacement field. Only SOLID185 (B-Bar, Simplified Enhanced Strain, Enhanced Strain formulations), SOLID186 (Full Integration) & SOLID187 elements are supported. Layered elements are not supported. Thermal strains are not supported. Only one value of material properties are allowed per element for isotropic and orthotropic elasticity. Material nonlinearity is not supported 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 XY shear component (01 component).

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.. Will only be used if no displacement input is given (will be applied on displacement operator).

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Optional if a mesh or a data_sources have been connected. Required if no displacement input have been connected.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Optional if a mesh or a streams_container have been connected, or if the displacement's field has a mesh support. Required if no displacement input have been connected.

pin 5optional
extrapolatename
(int32)expected type(s)

Whether to extrapolate the data from the integration points to the nodes.

pin 6optional
nonlinearname
(int32)expected type(s)

Whether to use nonlinear geometry or nonlinear material (1 = large strain, 2 = hyperelasticity).

pin 7optional
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

The underlying mesh. Optional if a data_sources or a streams_container have been connected, or if the displacement's field has a mesh support.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10optional
displacementname
(fields_container | field)expected type(s)

Field/or fields container containing only the displacement field (nodal). If none specified, read displacements from result file using the data_sources.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_total_strain_XY
  • full name: result.compute_total_strain_XY
  • internal name: compute_total_strain_XY
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_total_strain_XY() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.extrapolate.Connect(my_extrapolate)
op.inputs.nonlinear.Connect(my_nonlinear)
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.displacement.Connect(my_displacement)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_total_strain_XY() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.extrapolate.connect(my_extrapolate)
op.inputs.nonlinear.connect(my_nonlinear)
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.displacement.connect(my_displacement)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_total_strain_XY"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_extrapolate);
op.connect(6, my_nonlinear);
op.connect(7, my_abstract_meshed_region);
op.connect(9, my_requested_location);
op.connect(10, my_displacement);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute total strain YZ

Description

Computes the strain from a displacement field. Only SOLID185 (B-Bar, Simplified Enhanced Strain, Enhanced Strain formulations), SOLID186 (Full Integration) & SOLID187 elements are supported. Layered elements are not supported. Thermal strains are not supported. Only one value of material properties are allowed per element for isotropic and orthotropic elasticity. Material nonlinearity is not supported 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 YZ shear component (12 component).

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.. Will only be used if no displacement input is given (will be applied on displacement operator).

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Optional if a mesh or a data_sources have been connected. Required if no displacement input have been connected.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Optional if a mesh or a streams_container have been connected, or if the displacement's field has a mesh support. Required if no displacement input have been connected.

pin 5optional
extrapolatename
(int32)expected type(s)

Whether to extrapolate the data from the integration points to the nodes.

pin 6optional
nonlinearname
(int32)expected type(s)

Whether to use nonlinear geometry or nonlinear material (1 = large strain, 2 = hyperelasticity).

pin 7optional
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

The underlying mesh. Optional if a data_sources or a streams_container have been connected, or if the displacement's field has a mesh support.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10optional
displacementname
(fields_container | field)expected type(s)

Field/or fields container containing only the displacement field (nodal). If none specified, read displacements from result file using the data_sources.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_total_strain_YZ
  • full name: result.compute_total_strain_YZ
  • internal name: compute_total_strain_YZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_total_strain_YZ() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.extrapolate.Connect(my_extrapolate)
op.inputs.nonlinear.Connect(my_nonlinear)
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.displacement.Connect(my_displacement)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_total_strain_YZ() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.extrapolate.connect(my_extrapolate)
op.inputs.nonlinear.connect(my_nonlinear)
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.displacement.connect(my_displacement)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_total_strain_YZ"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_extrapolate);
op.connect(6, my_nonlinear);
op.connect(7, my_abstract_meshed_region);
op.connect(9, my_requested_location);
op.connect(10, my_displacement);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute total strain 1

Description

Computes the strain from a displacement field. Only SOLID185 (B-Bar, Simplified Enhanced Strain, Enhanced Strain formulations), SOLID186 (Full Integration) & SOLID187 elements are supported. Layered elements are not supported. Thermal strains are not supported. Only one value of material properties are allowed per element for isotropic and orthotropic elasticity. Material nonlinearity is not supported 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 1st principal component.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.. Will only be used if no displacement input is given (will be applied on displacement operator).

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Optional if a mesh or a data_sources have been connected. Required if no displacement input have been connected.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Optional if a mesh or a streams_container have been connected, or if the displacement's field has a mesh support. Required if no displacement input have been connected.

pin 5optional
extrapolatename
(int32)expected type(s)

Whether to extrapolate the data from the integration points to the nodes.

pin 6optional
nonlinearname
(int32)expected type(s)

Whether to use nonlinear geometry or nonlinear material (1 = large strain, 2 = hyperelasticity).

pin 7optional
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

The underlying mesh. Optional if a data_sources or a streams_container have been connected, or if the displacement's field has a mesh support.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10optional
displacementname
(fields_container | field)expected type(s)

Field/or fields container containing only the displacement field (nodal). If none specified, read displacements from result file using the data_sources.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_total_strain_1
  • full name: result.compute_total_strain_1
  • internal name: compute_total_strain_1
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_total_strain_1() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.extrapolate.Connect(my_extrapolate)
op.inputs.nonlinear.Connect(my_nonlinear)
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.displacement.Connect(my_displacement)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_total_strain_1() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.extrapolate.connect(my_extrapolate)
op.inputs.nonlinear.connect(my_nonlinear)
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.displacement.connect(my_displacement)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_total_strain_1"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_extrapolate);
op.connect(6, my_nonlinear);
op.connect(7, my_abstract_meshed_region);
op.connect(9, my_requested_location);
op.connect(10, my_displacement);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute total strain 2

Description

Computes the strain from a displacement field. Only SOLID185 (B-Bar, Simplified Enhanced Strain, Enhanced Strain formulations), SOLID186 (Full Integration) & SOLID187 elements are supported. Layered elements are not supported. Thermal strains are not supported. Only one value of material properties are allowed per element for isotropic and orthotropic elasticity. Material nonlinearity is not supported 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 2nd principal component.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.. Will only be used if no displacement input is given (will be applied on displacement operator).

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Optional if a mesh or a data_sources have been connected. Required if no displacement input have been connected.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Optional if a mesh or a streams_container have been connected, or if the displacement's field has a mesh support. Required if no displacement input have been connected.

pin 5optional
extrapolatename
(int32)expected type(s)

Whether to extrapolate the data from the integration points to the nodes.

pin 6optional
nonlinearname
(int32)expected type(s)

Whether to use nonlinear geometry or nonlinear material (1 = large strain, 2 = hyperelasticity).

pin 7optional
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

The underlying mesh. Optional if a data_sources or a streams_container have been connected, or if the displacement's field has a mesh support.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10optional
displacementname
(fields_container | field)expected type(s)

Field/or fields container containing only the displacement field (nodal). If none specified, read displacements from result file using the data_sources.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_total_strain_2
  • full name: result.compute_total_strain_2
  • internal name: compute_total_strain_2
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_total_strain_2() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.extrapolate.Connect(my_extrapolate)
op.inputs.nonlinear.Connect(my_nonlinear)
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.displacement.Connect(my_displacement)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_total_strain_2() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.extrapolate.connect(my_extrapolate)
op.inputs.nonlinear.connect(my_nonlinear)
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.displacement.connect(my_displacement)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_total_strain_2"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_extrapolate);
op.connect(6, my_nonlinear);
op.connect(7, my_abstract_meshed_region);
op.connect(9, my_requested_location);
op.connect(10, my_displacement);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute total strain 3

Description

Computes the strain from a displacement field. Only SOLID185 (B-Bar, Simplified Enhanced Strain, Enhanced Strain formulations), SOLID186 (Full Integration) & SOLID187 elements are supported. Layered elements are not supported. Thermal strains are not supported. Only one value of material properties are allowed per element for isotropic and orthotropic elasticity. Material nonlinearity is not supported 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 3rd principal component.

Inputs

pin 0optional
time_scopingname
(scoping | int32 | vector | double | field | vector)expected type(s)

time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1.. Will only be used if no displacement input is given (will be applied on displacement operator).

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Optional if a mesh or a data_sources have been connected. Required if no displacement input have been connected.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

Optional if a mesh or a streams_container have been connected, or if the displacement's field has a mesh support. Required if no displacement input have been connected.

pin 5optional
extrapolatename
(int32)expected type(s)

Whether to extrapolate the data from the integration points to the nodes.

pin 6optional
nonlinearname
(int32)expected type(s)

Whether to use nonlinear geometry or nonlinear material (1 = large strain, 2 = hyperelasticity).

pin 7optional
abstract_meshed_regionname
(abstract_meshed_region)expected type(s)

The underlying mesh. Optional if a data_sources or a streams_container have been connected, or if the displacement's field has a mesh support.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10optional
displacementname
(fields_container | field)expected type(s)

Field/or fields container containing only the displacement field (nodal). If none specified, read displacements from result file using the data_sources.

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_total_strain_3
  • full name: result.compute_total_strain_3
  • internal name: compute_total_strain_3
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_total_strain_3() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.extrapolate.Connect(my_extrapolate)
op.inputs.nonlinear.Connect(my_nonlinear)
op.inputs.abstract_meshed_region.Connect(my_abstract_meshed_region)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.displacement.Connect(my_displacement)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_total_strain_3() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.extrapolate.connect(my_extrapolate)
op.inputs.nonlinear.connect(my_nonlinear)
op.inputs.abstract_meshed_region.connect(my_abstract_meshed_region)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.displacement.connect(my_displacement)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_total_strain_3"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(5, my_extrapolate);
op.connect(6, my_nonlinear);
op.connect(7, my_abstract_meshed_region);
op.connect(9, my_requested_location);
op.connect(10, my_displacement);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute stress X

Description

Computes the stress from an elastic strain field. compute_total_strain limitations are applicable for stress computation Get the XX normal component (00 component).

Inputs

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Needed to get mesh and material ids. Optional if a data_sources have been connected.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

Needed to get mesh and material ids. Optional if a streams_container have been connected.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10requested
strainname
(fields_container | field)expected type(s)

Field/or fields container containing only the elastic strain field (element nodal).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_stress_X
  • full name: result.compute_stress_X
  • internal name: compute_stress_X
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_stress_X() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.strain.Connect(my_strain)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_stress_X() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.strain.connect(my_strain)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_stress_X"); // operator instantiation
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(9, my_requested_location);
op.connect(10, my_strain);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

compression: apply zfp

Description

Compressing input data using one of zfp compression algorithm modes.

Inputs

pin 0requested
dataInname
(field | fields_container)expected type(s)

field or fields container to be compressed

pin 1requested
modename
(string | char)expected type(s)

zfp mode: fixed-rate ('r'), fixed-precision ('p'), fixed-accuracy ('a')

pin 2requested
mode_parametername
(int32 | double)expected type(s)

mode-corresponding parameter: rate (double) / precision (int) / accuracy (double)

pin 3optional
dimname
(int32)expected type(s)

dimension (1D/2D/3D) for data organization before the compression (int; default: 2)

pin 4optional
ordername
(int32)expected type(s)

xyz dimensions order, where x (row) corresponds to number of elementary data, y (col) - number of time steps, z - number of components (applicable only for 3d data) : 0=xyz, 1=yxz (int; default: 0)

pin 5optional
double_absthresholdname
(double)expected type(s)

Double positive small value. All the values smaller than max(small value, max(vi) * relative threshold) are considered as zero values, (default value: 1.0e-18).

pin 6optional
double_relthresholdname
(double)expected type(s)

Double relative threshold. Values smaller than (v1 - v2) < max(small value, v1 * relativeTol) are considered identical (default value: 1.0e-10).

Outputs

pin 0requested
compress_speedname
(double)expected type(s)

the output entity is a double, containing compression speed of the input data: for ElementalNodal location - [elements/sec], for Nodal location - [nodes/sec]

pin 1requested
compress_rationame
(double)expected type(s)

the output entity is a double, containing compression rate = initial/compressed

pin 2requested
dataOutname
(custom_type_fields_container)expected type(s)

the output entity is a 'custom type field container'; each output field containing compressed results corresponding to one component data (ie. input vector field/fc contains 3 components will give 3 output fields), this is not the case when input pin3 is set to 3, all components will be compressed into one field.

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.
use_cudaIf this option is set to true, zfp fixed-rate parallel (de)compression will use CUDA.
(bool)expected type(s)
falsedefault value
: If this option is set to true, zfp fixed-rate parallel (de)compression will use CUDA.

Scripting

  • category: compression
  • plugin: core
  • scripting name: apply_zfp
  • full name: compression.apply_zfp
  • internal name: zfp
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.compression.apply_zfp() # operator instantiation
op.inputs.dataIn.Connect(my_dataIn)
op.inputs.mode.Connect(my_mode)
op.inputs.mode_parameter.Connect(my_mode_parameter)
op.inputs.dim.Connect(my_dim)
op.inputs.order.Connect(my_order)
op.inputs.double_absthreshold.Connect(my_double_absthreshold)
op.inputs.double_relthreshold.Connect(my_double_relthreshold)
my_compress_speed = op.outputs.compress_speed.GetData()
my_compress_ratio = op.outputs.compress_ratio.GetData()
my_dataOut = op.outputs.dataOut.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.compression.apply_zfp() # operator instantiation
op.inputs.dataIn.connect(my_dataIn)
op.inputs.mode.connect(my_mode)
op.inputs.mode_parameter.connect(my_mode_parameter)
op.inputs.dim.connect(my_dim)
op.inputs.order.connect(my_order)
op.inputs.double_absthreshold.connect(my_double_absthreshold)
op.inputs.double_relthreshold.connect(my_double_relthreshold)
my_compress_speed = op.outputs.compress_speed()
my_compress_ratio = op.outputs.compress_ratio()
my_dataOut = op.outputs.dataOut()
#include "dpf_api.h"

ansys::dpf::Operator op("zfp"); // operator instantiation
op.connect(0, my_dataIn);
op.connect(1, my_mode);
op.connect(2, my_mode_parameter);
op.connect(3, my_dim);
op.connect(4, my_order);
op.connect(5, my_double_absthreshold);
op.connect(6, my_double_relthreshold);
double my_compress_speed = op.getOutput<double>(0);
double my_compress_ratio = op.getOutput<double>(1);
ansys::dpf::CustomTypeFieldsContainer my_dataOut = op.getOutput<ansys::dpf::CustomTypeFieldsContainer>(2);

result: compute stress Y

Description

Computes the stress from an elastic strain field. compute_total_strain limitations are applicable for stress computation Get the YY normal component (11 component).

Inputs

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Needed to get mesh and material ids. Optional if a data_sources have been connected.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

Needed to get mesh and material ids. Optional if a streams_container have been connected.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10requested
strainname
(fields_container | field)expected type(s)

Field/or fields container containing only the elastic strain field (element nodal).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_stress_Y
  • full name: result.compute_stress_Y
  • internal name: compute_stress_Y
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_stress_Y() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.strain.Connect(my_strain)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_stress_Y() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.strain.connect(my_strain)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_stress_Y"); // operator instantiation
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(9, my_requested_location);
op.connect(10, my_strain);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute stress XZ

Description

Computes the stress from an elastic strain field. compute_total_strain limitations are applicable for stress computation Get the XZ shear component (02 component).

Inputs

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Needed to get mesh and material ids. Optional if a data_sources have been connected.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

Needed to get mesh and material ids. Optional if a streams_container have been connected.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10requested
strainname
(fields_container | field)expected type(s)

Field/or fields container containing only the elastic strain field (element nodal).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_stress_XZ
  • full name: result.compute_stress_XZ
  • internal name: compute_stress_XZ
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_stress_XZ() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.strain.Connect(my_strain)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_stress_XZ() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.strain.connect(my_strain)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_stress_XZ"); // operator instantiation
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(9, my_requested_location);
op.connect(10, my_strain);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

result: compute stress 1

Description

Computes the stress from an elastic strain field. compute_total_strain limitations are applicable for stress computation Get the 1st principal component.

Inputs

pin 1optional
scopingname
(scoping)expected type(s)

The element scoping on which the result is computed.

pin 3optional
streams_containername
(streams_container)expected type(s)

Needed to get mesh and material ids. Optional if a data_sources have been connected.

pin 4optional
data_sourcesname
(data_sources)expected type(s)

Needed to get mesh and material ids. Optional if a streams_container have been connected.

pin 9optional
requested_locationname
(string)expected type(s)

Average the Elemental Nodal result to the requested location.

pin 10requested
strainname
(fields_container | field)expected type(s)

Field/or fields container containing only the elastic strain field (element nodal).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)

The computed result fields container (elemental nodal).

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: result
  • plugin: live post
  • scripting name: compute_stress_1
  • full name: result.compute_stress_1
  • internal name: compute_stress_1
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.compute_stress_1() # operator instantiation
op.inputs.scoping.Connect(my_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.strain.Connect(my_strain)
my_fields_container = op.outputs.fields_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.compute_stress_1() # operator instantiation
op.inputs.scoping.connect(my_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.strain.connect(my_strain)
my_fields_container = op.outputs.fields_container()
#include "dpf_api.h"

ansys::dpf::Operator op("compute_stress_1"); // operator instantiation
op.connect(1, my_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(9, my_requested_location);
op.connect(10, my_strain);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);

mesh: decimate mesh

Description

Decimate a meshed region

Inputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)

Mesh to decimate

pin 1optional
preservation_rationame
(double)expected type(s)

Target ratio of elements to preserve, the actual number of elements preserved might differ. Default value is 0.5.

pin 2optional
aggressivenessname
(int32)expected type(s)

Quality measure for the resulting decimated mesh. Lower aggresiveness will provide a higher quality mesh with the tradeoff of higher execution time. Value range is 0 to 150, default is 0.

Outputs

pin 0requested
meshname
(abstract_meshed_region)expected type(s)

Decimated mesh with triangle elements

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: mesh
  • scripting name: decimate_mesh
  • full name: mesh.decimate_mesh
  • internal name: decimate_mesh
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.decimate_mesh() # operator instantiation
op.inputs.mesh.Connect(my_mesh)
op.inputs.preservation_ratio.Connect(my_preservation_ratio)
op.inputs.aggressiveness.Connect(my_aggressiveness)
my_mesh = op.outputs.mesh.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.decimate_mesh() # operator instantiation
op.inputs.mesh.connect(my_mesh)
op.inputs.preservation_ratio.connect(my_preservation_ratio)
op.inputs.aggressiveness.connect(my_aggressiveness)
my_mesh = op.outputs.mesh()
#include "dpf_api.h"

ansys::dpf::Operator op("decimate_mesh"); // operator instantiation
op.connect(0, my_mesh);
op.connect(1, my_preservation_ratio);
op.connect(2, my_aggressiveness);
ansys::dpf::MeshedRegion my_mesh = op.getOutput<ansys::dpf::MeshedRegion>(0);

mesh: acmo mesh provider

Description

Converts an Assembly Mesh into a DPF Meshes container

Inputs

pin 0requested
assembly_meshname
(ans_dispatch_holder | struct IAnsDispatch)expected type(s)
pin 1optional
unitname
(string)expected type(s)

Outputs

pin 0requested
meshes_containername
(meshes_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: mesh
  • plugin: core
  • scripting name: acmo_mesh_provider
  • full name: mesh.acmo_mesh_provider
  • internal name: acmo_mesh_provider
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.mesh.acmo_mesh_provider() # operator instantiation
op.inputs.assembly_mesh.Connect(my_assembly_mesh)
op.inputs.unit.Connect(my_unit)
my_meshes_container = op.outputs.meshes_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.mesh.acmo_mesh_provider() # operator instantiation
op.inputs.assembly_mesh.connect(my_assembly_mesh)
op.inputs.unit.connect(my_unit)
my_meshes_container = op.outputs.meshes_container()
#include "dpf_api.h"

ansys::dpf::Operator op("acmo_mesh_provider"); // operator instantiation
op.connect(0, my_assembly_mesh);
op.connect(1, my_unit);
ansys::dpf::MeshesContainer my_meshes_container = op.getOutput<ansys::dpf::MeshesContainer>(0);

result: von mises strains as mechanical

Description

Computes the equivalent (Von Mises) elastic strains and averages it to the nodes (by default). For multibody simulations, averaging across bodies can either be activated or deactivated.

Inputs

pin 0optional
time_scopingname
(scoping | vector)expected type(s)

time/freq (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.

pin 1optional
mesh_scopingname
(scoping | scopings_container)expected type(s)

nodes or elements scoping required in output.

pin 3optional
streams_containername
(streams_container)expected type(s)

result file container allowed to be kept open to cache data.

pin 4requested
data_sourcesname
(data_sources)expected type(s)

result file path container.

pin 7optional
meshname
(abstract_meshed_region | meshes_container)expected type(s)

prevents from reading the mesh in the results file.

pin 9optional
requested_locationname
(string)expected type(s)

average the elemental nodal result to the requested location (default is nodal).

pin 13optional
poisson_rationame
(int32 | double)expected type(s)

Poisson ratio to be used in equivalent strain calculation.

pin 14optional
read_cyclicname
(bool)expected type(s)

if true, cyclic expansion is done. If false, it's ignored.

pin 200optional
average_across_bodiesname
(bool)expected type(s)

for multibody simulations, the stresses are averaged across bodies if true or not if false (default).

Outputs

pin 0requested
fields_containername
(fields_container)expected type(s)
pin 1requested
meshes_containername
(meshes_container)expected type(s)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: result
  • plugin: mechanical_results
  • scripting name: strain_eqv_as_mechanical
  • full name: result.strain_eqv_as_mechanical
  • internal name: strain_eqv_as_mechanical
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.result.strain_eqv_as_mechanical() # operator instantiation
op.inputs.time_scoping.Connect(my_time_scoping)
op.inputs.mesh_scoping.Connect(my_mesh_scoping)
op.inputs.streams_container.Connect(my_streams_container)
op.inputs.data_sources.Connect(my_data_sources)
op.inputs.mesh.Connect(my_mesh)
op.inputs.requested_location.Connect(my_requested_location)
op.inputs.poisson_ratio.Connect(my_poisson_ratio)
op.inputs.read_cyclic.Connect(my_read_cyclic)
op.inputs.average_across_bodies.Connect(my_average_across_bodies)
my_fields_container = op.outputs.fields_container.GetData()
my_meshes_container = op.outputs.meshes_container.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.result.strain_eqv_as_mechanical() # operator instantiation
op.inputs.time_scoping.connect(my_time_scoping)
op.inputs.mesh_scoping.connect(my_mesh_scoping)
op.inputs.streams_container.connect(my_streams_container)
op.inputs.data_sources.connect(my_data_sources)
op.inputs.mesh.connect(my_mesh)
op.inputs.requested_location.connect(my_requested_location)
op.inputs.poisson_ratio.connect(my_poisson_ratio)
op.inputs.read_cyclic.connect(my_read_cyclic)
op.inputs.average_across_bodies.connect(my_average_across_bodies)
my_fields_container = op.outputs.fields_container()
my_meshes_container = op.outputs.meshes_container()
#include "dpf_api.h"

ansys::dpf::Operator op("strain_eqv_as_mechanical"); // operator instantiation
op.connect(0, my_time_scoping);
op.connect(1, my_mesh_scoping);
op.connect(3, my_streams_container);
op.connect(4, my_data_sources);
op.connect(7, my_mesh);
op.connect(9, my_requested_location);
op.connect(13, my_poisson_ratio);
op.connect(14, my_read_cyclic);
op.connect(200, my_average_across_bodies);
ansys::dpf::FieldsContainer my_fields_container = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::MeshesContainer my_meshes_container = op.getOutput<ansys::dpf::MeshesContainer>(1);

compression: apply svd

Description

Computes the coefficients (=U*Sigma) and VT components from SVD.

Inputs

pin 0requested
field_contaner_to_compressname
(fields_container)expected type(s)

fields container to be compressed

pin 1requested
scalar_intname
(int32)expected type(s)

number of vectors (r) to keep for the future reconstraction of the matrix A, ex. A[m,n]=coef[m,r]VT[r,n], where coef=USigma

pin 2requested
scalar_doublename
(double)expected type(s)

threshold (precision) as a double, default value is 1e-7. If both pin1 and pin2 are provided, choose the min r-vectors

pin 3requested
booleanname
(bool)expected type(s)

apply svd on the initial data (Default : false), otherwise use reduced data (square matrix with the smallest dimensions).

Outputs

pin 0requested
us_svdname
(fields_container)expected type(s)

the output entity is a field container (time dependant); it contains the multiplication of two matrices, U and S, where A=U.S.Vt

pin 1requested
vt_svdname
(fields_container)expected type(s)

the output entity is a field container (space dependant), containing the Vt, where A=U.S.Vt

pin 2requested
sigmaname
(field | fields_container)expected type(s)

the output entity is a field (or a field container if input fc contains several labels, where field contains results per label), containing singular (S) values of the input data, where A=U.S.Vt

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
num_threadsNumber of threads to use to run in parallel
(int32)expected type(s)
0default value
: Number of threads to use to run in parallel
run_in_parallelLoops are allowed to run in parallel if the value of this config is set to true.
(bool)expected type(s)
truedefault value
: Loops are allowed to run in parallel if the value of this config is set to true.

Scripting

  • category: compression
  • plugin: core
  • scripting name: apply_svd
  • full name: compression.apply_svd
  • internal name: svd_operator
  • license: any_dpf_supported_increments
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.compression.apply_svd() # operator instantiation
op.inputs.field_contaner_to_compress.Connect(my_field_contaner_to_compress)
op.inputs.scalar_int.Connect(my_scalar_int)
op.inputs.scalar_double.Connect(my_scalar_double)
op.inputs.boolean.Connect(my_boolean)
my_us_svd = op.outputs.us_svd.GetData()
my_vt_svd = op.outputs.vt_svd.GetData()
my_sigma = op.outputs.sigma.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.compression.apply_svd() # operator instantiation
op.inputs.field_contaner_to_compress.connect(my_field_contaner_to_compress)
op.inputs.scalar_int.connect(my_scalar_int)
op.inputs.scalar_double.connect(my_scalar_double)
op.inputs.boolean.connect(my_boolean)
my_us_svd = op.outputs.us_svd()
my_vt_svd = op.outputs.vt_svd()
my_sigma = op.outputs.sigma()
#include "dpf_api.h"

ansys::dpf::Operator op("svd_operator"); // operator instantiation
op.connect(0, my_field_contaner_to_compress);
op.connect(1, my_scalar_int);
op.connect(2, my_scalar_double);
op.connect(3, my_boolean);
ansys::dpf::FieldsContainer my_us_svd = op.getOutput<ansys::dpf::FieldsContainer>(0);
ansys::dpf::FieldsContainer my_vt_svd = op.getOutput<ansys::dpf::FieldsContainer>(1);
ansys::dpf::Field my_sigma = op.getOutput<ansys::dpf::Field>(2);

compression: zfp decompression

Description

zfp decompression using the information about compression written into the properties of the field(s)

Inputs

pin 0requested
dataInname
(custom_type_fields_container)expected type(s)

custom type field container from zfp_compression operator to decompress

Outputs

pin 0requested
dataOutname
(field | fields_container)expected type(s)

the output entity is a field or a fields container; it contains decompressed data

pin 1requested
decompress_speedname
(double)expected type(s)

the output entity is a double, containing decompression speed (mb/sec)

Configurations

mutexIf this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.
(bool)expected type(s)
falsedefault value
: If this option is set to true, the shared memory is prevented from being simultaneously accessed by multiple threads.

Scripting

  • category: compression
  • plugin: core
  • scripting name: zfp_decompress
  • full name: compression.zfp_decompress
  • internal name: zfp_decompress
  • license: none
Example of usage
import mech_dpf
import Ans.DataProcessing as dpf

op = dpf.operators.compression.zfp_decompress() # operator instantiation
op.inputs.dataIn.Connect(my_dataIn)
my_dataOut = op.outputs.dataOut.GetData()
my_decompress_speed = op.outputs.decompress_speed.GetData()
from ansys.dpf import core as dpf 

op = dpf.operators.compression.zfp_decompress() # operator instantiation
op.inputs.dataIn.connect(my_dataIn)
my_dataOut = op.outputs.dataOut()
my_decompress_speed = op.outputs.decompress_speed()
#include "dpf_api.h"

ansys::dpf::Operator op("zfp_decompress"); // operator instantiation
op.connect(0, my_dataIn);
ansys::dpf::Field my_dataOut = op.getOutput<ansys::dpf::Field>(0);
double my_decompress_speed = op.getOutput<double>(1);