Solving Linear & Non-Linear Engineering Equations

The Engineering Problem

Engineering analysis requires solving equations — linear systems for static structural analysis, non-linear equations for contact and plasticity, root-finding for equilibrium and stability. The method used to solve these equations affects both the accuracy and the reliability of the result. Understanding the methods and their limitations is essential for interpreting computational output.

Linear Systems

A linear system A x = b is the foundation of linear static FEA. The stiffness matrix K, displacement vector u and force vector F form a linear system K u = F. Direct methods (LU decomposition, Cholesky factorisation) solve the system in a fixed number of operations. Iterative methods (conjugate gradient, GMRES) approach the solution through successive approximations and are preferred for very large, sparse systems.

A x  =  b

Direct solve:  x  =  A⁻¹ b   (conceptually — in practice, factorise and substitute)

LU decomposition:
A  =  L U
L y  =  b   (forward substitution)
U x  =  y   (backward substitution)

Non-Linear Equations

Non-linear equations arise when the stiffness depends on the displacement — contact, plasticity, large deformation. The equation f(x) = 0 cannot be solved by direct factorisation. Instead, iterative methods refine an initial guess until the residual is sufficiently small.

f(x)  =  0

Newton–Raphson update:

x_{n+1}  =  x_n  −  f(x_n) / f'(x_n)

Convergence:  |f(x_n)|  <  tolerance

Newton–Raphson Method

The Newton–Raphson method is the most common approach for solving non-linear engineering equations. At each iteration, the method linearises the problem around the current estimate and solves the linearised system. When it works, convergence is quadratic — the error roughly squares each iteration. When it fails, it can diverge or converge to an unintended solution.

• Quadratic convergence near the solution — very fast once close
• Requires the Jacobian (derivative matrix) — the tangent stiffness in FEA
• Sensitive to initial guess — a poor guess can cause divergence
• Can converge to an unintended solution if multiple solutions exist
• May require line search or arc-length control for robustness

A numerical solver can converge to an unwanted solution — convergence must still be interpreted physically.

Engineering Example — Non-Linear FEA

In non-linear static FEA, the stiffness matrix depends on the current displacement state. The solver iterates: apply load, compute displacement using current stiffness, update stiffness based on new displacement, check equilibrium, repeat. Each iteration is a Newton–Raphson step. The tangent stiffness matrix is the Jacobian. Convergence means the residual force is below a tolerance — the internal forces balance the external forces.

Apply load → Solve with current K → Update displacement → Update K → Check equilibrium → Converged?

Convergence Sensitivity

Non-linear solvers are sensitive to the initial guess, the load increment size and the material model. A load that is too large in a single increment may cause the solver to diverge. A material model with a sharp transition (snap-through buckling, material softening) may require arc-length methods to track the solution path. Understanding why a solver fails to converge is often more important than the fact that it failed.

• Initial guess — closer to the solution means faster, more reliable convergence
• Load increment — smaller increments improve convergence but increase computation time
• Material non-linearity — sharp transitions can cause convergence difficulties
• Contact — status changes between iterations can disrupt convergence
• Arc-length methods — trace the equilibrium path through limit points

Fixed-Point Methods

Fixed-point iteration rearranges f(x) = 0 into x = g(x) and iterates x_{n+1} = g(x_n). The method is simpler than Newton–Raphson — no derivative needed — but convergence is typically linear (slower) and depends on the contraction property of g. It can be useful where derivatives are difficult to compute or where Newton–Raphson is unstable.

Fixed-point form:

x  =  g(x)

Iteration:

x_{n+1}  =  g(x_n)

Convergence requires  |g'(x)|  <  1  near the solution

Common Mistakes

• Interpreting convergence as correctness — a converged solution may solve the wrong equation
• Using too large a load increment for non-linear problems — causing divergence
• Not checking the residual against an engineering tolerance, only the solver default
• Assuming a non-linear solver will find the physically correct solution if multiple exist
• Ignoring solver warnings about cutbacks, iterations or negative eigenvalues

Verification

Non-linear solutions should be verified by checking equilibrium (do the reaction forces balance the applied loads?), by comparing against a linear solution for a case where non-linearity is negligible, and by confirming that the result is insensitive to load increment size.

ENGINEERING CHECK: Do the reaction forces balance the applied loads? Equilibrium is a necessary condition for a valid solution, regardless of convergence status.

When a Simpler Method Is Better

If a problem is only mildly non-linear, a linear solution with an appropriate safety factor may be more practical than a full non-linear analysis. If a single load case can be approximated by a hand calculation, a non-linear FEA model may be unnecessary. The engineering question — not the available solver capability — should determine the method.

Key Takeaways

• Linear systems are solved directly; non-linear systems require iterative methods
• Newton–Raphson converges quadratically but is sensitive to initial guess and load increment
• Convergence means the residual is small — it does not automatically mean the solution is physically correct
• A solver can converge to an unwanted solution when multiple exist
• Equilibrium checks are a necessary verification regardless of solver convergence status