Results

StaticResult is the numerical source of truth after a linear-static solve. It stores a frozen snapshot of the problem and solution at the time the analysis was performed.

Creating a result

The most common form is:

result = model.solve()

The equivalent explicit analysis call is:

from nusa import LinearStaticAnalysis

result = LinearStaticAnalysis().solve(model)

Both forms return nusa.result.StaticResult.

Primary arrays

The result exposes defensive copies of the main solved vectors:

applied_loads: External nodal loads specified in the model.
prescribed_displacements: Prescribed displacement vector. Free DOFs are represented by nan.
displacements: Solved generalized displacement vector.
nodal_forces: Generalized nodal force vector obtained from K @ u.
reactions: Constraint reactions, evaluated from the difference between the force required by the solved state and the applied load.
element_results: Canonical result dictionaries in element order.

Example:

print(result.displacements)
print(result.reactions)
print(result.element_results)

Object-based queries

For most user code, object-based accessors are easier to read than indexing the global arrays manually:

result.applied_load(node)
result.prescribed_displacement(node)
result.displacement(node)
result.nodal_force(node)
result.reaction(node)
result.element_result(element)

The returned dictionaries use the DOF names associated with the model family. For example, a truss node returns ux/uy displacements and fx/fy forces, while a beam node returns uy/ur displacements and fy/m actions.

Element results

Each element family exposes a canonical result schema:

Canonical element results
Element	Result keys
Spring	`force_i`, `force_j`
Bar	`force_i`, `force_j`, `axial_force`, `axial_stress`
Truss	`axial_force`, `axial_stress`
Beam	`shear_force_i`, `shear_force_j`, `bending_moment_i`, `bending_moment_j`
LinearTriangle	`stress_xx`, `stress_yy`, `stress_xy`, `strain_xx`, `strain_yy`, `strain_xy`

Example:

values = result.element_result(element)
print(values["axial_force"])

Snapshot semantics

A result does not change if the model is later modified:

result1 = model.solve()

model.add_force(node, (20.0,))
result2 = model.solve()

result1 still represents the first analysis, while result2 represents the modified problem.

The result also stores frozen geometry, labels, connectivity, DOF metadata, and model name. This allows reporting and visualization to remain stable even when the original model objects are later edited.

Post-processing delegates

StaticResult provides convenience methods that delegate to NuSA’s post-processing functions:

result.element_field("stress_xx")
result.nodal_field("stress_xx")
result.nodal_field("von_mises_stress")

See Post-processing for recovery policies and derived fields.

Reporting and visualization delegates

A result can also be used directly for solved reporting and visualization:

result.simple_report()
result.plot_deformed_shape()
result.plot_nodal_field("stress_xx")
result.plot_element_field("stress_xx")

Beam results additionally expose:

result.plot_shear_diagram()
result.plot_moment_diagram()

API reference

Result objects for NuSA finite-element analyses.

class nusa.result.StaticResult(*, model_name, node_objects, node_labels, node_coordinates, element_objects, element_labels, element_types, connectivity, displacement_dofs, force_dofs, applied_loads, prescribed_displacements, displacements, nodal_forces, reactions, element_results)[source]

Bases: object

Stable snapshot of one completed linear-static analysis.

Instances are produced by nusa.solve() or nusa.LinearStaticAnalysis. Public array properties return copies so callers cannot mutate the stored result.

Attributes:

applied_loads: Applied nodal-load vector captured for this analysis.
connectivity: Element connectivity as frozen result-node indices.
displacement_dofs: Displacement component names in per-node order.
displacements: Complete solved global displacement vector.
element_labels: Element labels in frozen result order.
element_results: Canonical element results in frozen result order.
element_types: Element type names in frozen result order.
force_dofs: Generalized force component names in per-node order.
model_name: Model name captured at solve time.
nodal_forces: Solved generalized nodal-force vector K @ u.
node_coordinates: Node coordinates in frozen result order.
node_labels: Node labels in frozen result order.
prescribed_displacements: Prescribed-displacement vector captured for this analysis.
reactions: Support-reaction vector for prescribed degrees of freedom.

Methods

`applied_load`(node)	Return applied load components for one result node.
`displacement`(node)	Return solved displacement components for one result node.
`element_field`(name)	Return one scalar element field in result order.
`element_result`(element)	Return canonical primary results for one element.
`nodal_field`(name[, recovery])	Return one scalar nodal field, recovering element values if needed.
`nodal_force`(node)	Return solved generalized nodal-force components for one node.
`plot_deformed_shape`([scale, ax])	Plot the frozen deformed geometry.
`plot_element_field`(field[, ax])	Plot a scalar element field.
`plot_moment_diagram`([ax])	Plot beam bending moments from frozen element results.
`plot_nodal_field`(field[, ax, recovery])	Plot a scalar nodal field.
`plot_shear_diagram`([ax])	Plot beam shear forces from frozen element results.
`prescribed_displacement`(node)	Return prescribed displacement components for one result node.
`reaction`(node)	Return support-reaction components for one node.
`simple_report`([report_type, fname])	Generate a compact text report from this result snapshot.

applied_load(node)[source]: Return applied load components for one result node.

property applied_loads: Applied nodal-load vector captured for this analysis.

property connectivity: Element connectivity as frozen result-node indices.

displacement(node)[source]: Return solved displacement components for one result node.

property displacement_dofs: Displacement component names in per-node order.

property displacements: Complete solved global displacement vector.

element_field(name)[source]: Return one scalar element field in result order.

property element_labels: Element labels in frozen result order.

element_result(element)[source]: Return canonical primary results for one element.

property element_results: Canonical element results in frozen result order.

property element_types: Element type names in frozen result order.

property force_dofs: Generalized force component names in per-node order.

property model_name: Model name captured at solve time.

nodal_field(name, recovery='average')[source]: Return one scalar nodal field, recovering element values if needed.

nodal_force(node)[source]: Return solved generalized nodal-force components for one node.

property nodal_forces: Solved generalized nodal-force vector K @ u.

property node_coordinates: Node coordinates in frozen result order.

property node_labels: Node labels in frozen result order.

plot_deformed_shape(scale=1.0, ax=None, **kwargs)[source]: Plot the frozen deformed geometry.

plot_element_field(field, ax=None)[source]: Plot a scalar element field.

plot_moment_diagram(ax=None)[source]: Plot beam bending moments from frozen element results.

plot_nodal_field(field, ax=None, recovery='average')[source]: Plot a scalar nodal field.

plot_shear_diagram(ax=None)[source]: Plot beam shear forces from frozen element results.

prescribed_displacement(node)[source]: Return prescribed displacement components for one result node.

property prescribed_displacements: Prescribed-displacement vector captured for this analysis.

reaction(node)[source]: Return support-reaction components for one node.

property reactions: Support-reaction vector for prescribed degrees of freedom.

simple_report(report_type='print', fname='nusa_rpt.txt')[source]: Generate a compact text report from this result snapshot.