How to plot stress envelope S1max - S3max over multi-step analysis

Hi all,

I'm working in Ansys Mechanical 2025 R2, using a Python Result object to extract and visualize the principal stress envelope (S1 − S3) over time.

Hi all,

I'm working in Ansys Mechanical 2025 R2, trying to use a Python Result object to extract and visualize the principal stress envelope (S1 − S3) over time.

Here’s exactly what I’m trying to do:

Use a Python Result object in Ansys Mechanical (not standalone DPF).

For a multi-step structural analysis, extract:

S1: Maximum principal stress (1st principal)

S3: Minimum principal stress (3rd principal)

Compute the difference (S1 − S3) at each node or element.

Display this difference as a contour result in Mechanical, with time scoping (i.e. I want to scroll through time steps).

Ideally, I’d like to make the time step detection automatic — but hardcoding [1,2,3] is fine for now.

I’ve tried using both math.minus() and math.minus_fc(), but consistently run into attribute errors such as:

'InputSpec' object has no attribute 'field'

'InputSpec' object has no attribute 'fields_containerA'

'TimeFreqSupport' object has no attribute 'TimeScoping'

'TimeFreqSupport' object has no attribute 'TimeFreqIds'

So far, my only reliably working script is one that displays just S1 using SetOutputContour(s1). When I try to build on this to subtract S3, I run into the issues above.

🔍 What I’d really appreciate help with:

The correct way (in 2025 R2) to:

Loop over all time steps

Compute S1 − S3

Build a FieldsContainer or DPF workflow that can be plotted

Clarification on which operator input names are valid in Python Result (fieldA, fields_containerA, Connect(0,...), etc.)

How to reliably get the list of time step IDs from the result file in Mechanical

🛠️ Example of what I tried:
s1 = dpf.operators.result.stress_principal_1()
s3 = dpf.operators.result.stress_principal_3()
subtract = dpf.operators.math.minus()
subtract.inputs.fieldA.Connect(s1.outputs.field)
subtract.inputs.fieldB.Connect(s3.outputs.field)

This results in:

AttributeError: 'OutputSpec' object has no attribute 'field'

Any guidance or working examples would be massively appreciated 🙏
Thanks in advance!

Find more posts tagged with

Accepted answers

Mike.Thompson

This is an example of what you are looking for:

analysis  = Model.Analyses[0]  #get the analysis any way you want
dataSource = dpf.DataSources(analysis.ResultFileName)
#Time scoping per your needs....
TimeScoping = dpf.TimeFreqScopingFactory.ScopingByLoadSteps([1,2,3])

#Do the stress operators
P1=dpf.operators.result.stress_principal_1()
P1.inputs.data_sources.Connect(dataSource)
P1.inputs.time_scoping.Connect(TimeScoping)

P3=dpf.operators.result.stress_principal_3()
P3.inputs.data_sources.Connect(dataSource)
P3.inputs.time_scoping.Connect(TimeScoping)

#take the difference.
Diff_op = dpf.operators.math.minus_fc()
Diff_op.inputs.field_or_fields_container_A.Connect(P1)
Diff_op.inputs.field_or_fields_container_B.Connect(P3)
Diff_FC=Diff_op.outputs.fields_container.GetData()

All comments

Mike.Thompson

This is an example of what you are looking for:

analysis  = Model.Analyses[0]  #get the analysis any way you want
dataSource = dpf.DataSources(analysis.ResultFileName)
#Time scoping per your needs....
TimeScoping = dpf.TimeFreqScopingFactory.ScopingByLoadSteps([1,2,3])

#Do the stress operators
P1=dpf.operators.result.stress_principal_1()
P1.inputs.data_sources.Connect(dataSource)
P1.inputs.time_scoping.Connect(TimeScoping)

P3=dpf.operators.result.stress_principal_3()
P3.inputs.data_sources.Connect(dataSource)
P3.inputs.time_scoping.Connect(TimeScoping)

#take the difference.
Diff_op = dpf.operators.math.minus_fc()
Diff_op.inputs.field_or_fields_container_A.Connect(P1)
Diff_op.inputs.field_or_fields_container_B.Connect(P3)
Diff_FC=Diff_op.outputs.fields_container.GetData()

Jeanri

Thank you so much— I used ths amended script (I’m using in a Python Result) to get S1 − S3 for steps [1, 2, 3] successfully:

def post_started(sender, analysis): # Do not edit this line
define_dpf_workflow(analysis)

def table_retrieve_result(value): # Do not edit this line
import mech_dpf
import Ans.DataProcessing as dpf
wf = dpf.Workflow(this.WorkflowId)
wf.Connect('contour_selector', value)
this.Evaluate()

def define_dpf_workflow(analysis):
import mech_dpf
import Ans.DataProcessing as dpf
mech_dpf.setExtAPI(ExtAPI)

# Use the analysis already passed to this function
dataSource = dpf.DataSources(analysis.ResultFileName)

# Time scoping for load steps 1, 2, 3
# If TimeFreqScopingFactory is available, use it; otherwise fall back.
try:
    TimeScoping = dpf.TimeFreqScopingFactory.ScopingByLoadSteps([1, 2, 3])
except:
    TimeScoping = dpf.Scoping()
    TimeScoping.Ids = [1, 2, 3]

# Principal stresses
P1 = dpf.operators.result.stress_principal_1()
P1.inputs.data_sources.Connect(dataSource)
P1.inputs.time_scoping.Connect(TimeScoping)

P3 = dpf.operators.result.stress_principal_3()
P3.inputs.data_sources.Connect(dataSource)
P3.inputs.time_scoping.Connect(TimeScoping)

# Difference S1 - S3 (operator-level Connect for reliability)
Diff_op = dpf.operators.math.minus_fc()
Diff_op.Connect(0, P1, 0)   # first FC input from P1 (output 0)
Diff_op.Connect(1, P3, 0)   # second FC input from P3 (output 0)

# Build workflow and set contour to the difference operator
wf = dpf.Workflow()
wf.Add(Diff_op)
wf.SetOutputContour(Diff_op)
wf.Record('wf_id', False)
this.WorkflowId = wf.GetRecordedId()

But I need to compute a running envelope per time — i.e., at step t use
running_S1max(t) = max_{τ ≤ t} S1, running_S3min(t) = min_{τ ≤ t} S3, and plot the development of running_S1max(t) − running_S3min(t) (ideally as a contour per node and/or as a time history).

Here’s what I tried inside Python Result and the exact errors I hit:

Try to use single-time Field outputs:

s1 = dpf.operators.result.stress_principal_1()
s3 = dpf.operators.result.stress_principal_3()
minus = dpf.operators.math.minus()
minus.inputs.fieldA.Connect(s1.outputs.field)
minus.inputs.fieldB.Connect(s3.outputs.field)

Error: AttributeError: 'OutputSpec' object has no attribute 'field'
(In this binding the result ops expose a FieldsContainer, not a Field, even for one time ID.)

Try minus_fc with named pins:

subtract_op = dpf.operators.math.minus_fc()
subtract_op.inputs.fields_containerA.Connect(s1.outputs.fields_container)
subtract_op.inputs.fields_containerB.Connect(s3.outputs.fields_container)

Error: AttributeError: 'InputSpec' object has no attribute 'fields_containerA'
(Same for fieldsA, fields_containerB, fieldsB.)

Try .inputs.connect() / .inputs.Connect():

subtract_op = dpf.operators.math.minus_fc()
subtract_op.inputs.connect(0, s1.outputs.fields_container)
subtract_op.inputs.connect(1, s3.outputs.fields_container)

Error: AttributeError: 'InputSpec' object has no attribute 'connect'
(Operator-level Connect(pin, upstream, out_pin) works — that’s what I used in the working script.)

Try to read the FieldsContainer directly from a linkable output:

fc = s1_t.outputs.fields_container # LinkableOutput[FieldsContainer]
n = fc.Size # or fc.get_number_of_fields(), or calling fc()

Errors seen:
AttributeError: 'LinkableOutput[FieldsContainer]' object has no attribute 'Size'
TypeError: LinkableOutput[FieldsContainer] is not callable
(I couldn’t find a supported way in Python Result to dereference the linkable output into a real FC/Field to compute my own max/min.)

Try min/max operators to get global or field-wise extrema:

op_mx = dpf.operators.min_max.max_fc()
op_mn = dpf.operators.min_max.min_fc()

Errors:
AttributeError: attribute 'max_fc' of 'namespace#' object is read-only
AttributeError: attribute 'max' of 'namespace#' object is read-only
(The min_max namespace appears locked in this Python Result binding.)

Try creating min/max via the generic factory and wiring them:

op_max_fc = dpf.Operator("min_max::max_fc")
op_max_fc.Connect(0, s1_t, 0)

Runtime error (in some variants):
Exception: Operator.connect_operator_output error: : down stream operator pointer null-

Because of these, I’m stuck: I can output the plain S1 − S3 contour across steps (script above works), but I can’t compute the running max/min (global or per-node) inside the same Python Result.

Request for advice:

In Mechanical 2025 R2 Python Result, what is the supported pattern to:

create and connect field-wise min/max operators (min_max::max, min_max::min) or their FC counterparts, and/or

safely dereference a linkable fields_container output to a Field/FC so I can compute my own running extrema?

If the recommended approach is to build the DPF workflow outside the Python Result (Scripting Console/Extension) and then just call SetOutputContour(workflow_output) from the Python Result, could you share a minimal snippet for a running per-node envelope over steps [1,2,3]?

Mike.Thompson

You can create a fields container from scratch and add fields to it. In this way you can use simple pythonic tools to see what the max is across the fields.

Get the fields containers for S1, S3: Called S1_FC, S3_FC
Create another fields container for the S1-S3 running totals you want to eventually plot. Call it Diff_FC
The first field is only the difference S1-S3 for the first field result, as this is by definition the max/min at this point.
For all other fields use:
1. MaxS1Data = [max(V1,V2) for V1, V2, in zip(S1_FC[i].Data, Diff_FC[i-1].Data)]
2. MinS3Data = [min(V1,V2) for V1, V2, in zip(S3_FC[i].Data, Diff_FC[i-1].Data)]
3. DiffField.Data = [my_max - my_min for my_max, my_min in zip(MaxS1Data,MinS3Data)]
4. Add DiffField to fields container: Diff_FC.Add(DiffField, {"Time":my_time_point})