15.3. Direct Evaluation of Euler–Almansi Strains and Comparison of UL Approaches

Purpose and progression

This section grew out of discussions with Chiara, whose contribution was decisive in developing the idea of evaluating the Euler–Almansi strain directly from the current configuration.

Section 15.1 and Section 15.2 evaluate the Euler–Almansi strain through incremental procedures. The present section investigates whether the same strain can instead be evaluated directly from the total current deformation.

Section 15.1Geometry updated after every iteration; explicit Euler–Almansi component expressions with the characteristic minus signs; incremental accumulation.

Section 15.2 — stiffSimple additive strain update.

Section 15.2 — stiff2Accumulated strain and new strain increment transformed to the new current configuration.

Section 15.3 — stiff3Direct Euler–Almansi evaluation from the current configuration.

The transformed update used by stiff2 is:

\boldsymbol e_{i+1}=\boldsymbol F_\Delta^{-T}\left(\boldsymbol e_i+\Delta\boldsymbol E\right)\boldsymbol F_\Delta^{-1}

The simple additive approximation applies to stiff. In stiff2, the accumulated strain and the new strain increment are transformed together to the new current configuration. This transformation is kinematically equivalent to the direct Euler–Almansi evaluation used in stiff3.

Direct Euler–Almansi strain

The Euler–Almansi strain introduced in Chapter 13 is:

\boxed{\boldsymbol e=\frac12\left(\boldsymbol I-\boldsymbol b^{-1}\right)}

where:

\boldsymbol b=\boldsymbol F\boldsymbol F^T

Here, $\boldsymbol F$ is the total deformation gradient from the initial configuration to the current trial configuration, not merely the deformation gradient of the latest load increment. No previously accumulated strain is required to evaluate the current strain. The Euler–Almansi strain is obtained directly from the total deformation of the current trial configuration.

In engineering notation:

e_x=e_{11}\qquad e_y=e_{22}\qquad \gamma_{xy}=2e_{12}

stiff3 does not use $\boldsymbol e_i+\Delta\boldsymbol E$ and does not need strnt(:,:,istep) to calculate the current trial strain at load step $i+1$ . The array strnt remains only to store strain results for post-processing.

The complete finite-element algorithm nevertheless retains the linear elastic material assumption, the small-strain plane-stress thickness approximation, and the adopted internal-force formulation and approximate tangent stiffness discussed in Sections 15.1 and 15.2.

Initial and current trial geometries

At each Gauss point, $\boldsymbol J_0$ is the Jacobian of the initial undeformed configuration and $\boldsymbol J_t$ is the Jacobian of the current trial configuration.

Using the notation introduced in Chapter 13, $\boldsymbol x$ denotes the position in the initial configuration and $\hat{\boldsymbol x}$ the position in the current configuration.

For an infinitesimal line element:

d\boldsymbol x=\boldsymbol J_0^T d\boldsymbol\xi,\qquad d\hat{\boldsymbol x}=\boldsymbol J_t^T d\boldsymbol\xi

Eliminating $d\boldsymbol\xi$ :

d\hat{\boldsymbol x}=\boldsymbol J_t^T\boldsymbol J_0^{-T}d\boldsymbol x=\left(\boldsymbol J_0^{-1}\boldsymbol J_t\right)^T d\boldsymbol x

Since, by definition:

d\hat{\boldsymbol x}=\boldsymbol F_{\mathrm{tot}}d\boldsymbol x

it follows that:

\boxed{\boldsymbol F_{\mathrm{tot}}=\left(\boldsymbol J_0^{-1}\boldsymbol J_t\right)^T}

The current trial nodal coordinates are obtained from the known configuration at the beginning of the load step plus the accumulated displacement increment of that step:

\boldsymbol x_t=\boldsymbol x_i+\Delta\boldsymbol u

The implementation uses the initial nodal coordinates x0 and y0 stored by gen.m.

This matrix maps the initial material geometry directly to the current trial geometry. It therefore includes the complete deformation accumulated from the initial configuration, rather than only the latest increment.

The left Cauchy–Green tensor and the direct Euler–Almansi strain follow as:

\boldsymbol b=\boldsymbol F_{\mathrm{tot}}\boldsymbol F_{\mathrm{tot}}^T

\boldsymbol e=\frac12\left(\boldsymbol I-\boldsymbol b^{-1}\right)

MATLAB implementation

stiff3 was developed from the stiff routine of Section 15.2 so that only the strain-evaluation procedure changes. The geometry update after load-step convergence, $\boldsymbol B=\boldsymbol B_0+\boldsymbol B_L$ , the $\boldsymbol G_x,\boldsymbol G_y,\boldsymbol G_{xy}$ terms, the internal force, the adopted tangent stiffness, the thickness approximation, load stepping, and convergence tolerance are retained.

The new conceptual block is:

% Current trial nodal coordinates
xelt=xel+sel(1:2:8);
yelt=yel+sel(2:2:8);

% Initial and current trial Jacobians
J0=H*[xel0 yel0];
Jt=H*[xelt yelt];

% Total deformation gradient
Ftot=(J0\Jt)';

% Left Cauchy-Green tensor
btens=Ftot*Ftot';

% Euler-Almansi strain tensor
ee=0.5*(eye(2)-inv(btens));

ex =ee(1,1);
ey =ee(2,2);
exy=2*ee(1,2);

The current trial coordinates used to form $\boldsymbol J_t$ are:

xelt=xel+sel(1:2:8)
yelt=yel+sel(2:2:8)

The plane-stress thickness remains the same small-strain approximation:

\varepsilon_z=-\frac{\nu}{1-\nu}(\varepsilon_x+\varepsilon_y)

h_{\mathrm{cur}}\approx(1+\varepsilon_z)h

This thickness relation is a small-strain approximation; it is not a general exact relation for finite elastic strains.

Equivalence of `stiff2` and `stiff3`

Let $\boldsymbol F_i$ be the total deformation gradient from the initial configuration to configuration $i$ , and $\boldsymbol F_\Delta$ the incremental deformation gradient from configuration $i$ to configuration $i+1$ . Then:

\boldsymbol F_{i+1}=\boldsymbol F_\Delta\boldsymbol F_i

The Euler–Almansi strain at configuration $i$ is:

\boldsymbol e_i=\frac12\left(\boldsymbol I-\boldsymbol F_i^{-T}\boldsymbol F_i^{-1}\right)

The Green–Lagrange strain increment for $i\rightarrow i+1$ is:

\Delta\boldsymbol E=\frac12\left(\boldsymbol F_\Delta^T\boldsymbol F_\Delta-\boldsymbol I\right)

Substitution into the stiff2 update gives:

\begin{aligned}\boldsymbol e_{i+1}&=\boldsymbol F_\Delta^{-T}\left(\boldsymbol e_i+\Delta\boldsymbol E\right)\boldsymbol F_\Delta^{-1}\\[3pt]&=\frac12\left[\boldsymbol I-\boldsymbol F_\Delta^{-T}\boldsymbol F_i^{-T}\boldsymbol F_i^{-1}\boldsymbol F_\Delta^{-1}\right]\\[3pt]&=\frac12\left[\boldsymbol I-\boldsymbol F_{i+1}^{-T}\boldsymbol F_{i+1}^{-1}\right]\\[3pt]&=\frac12\left(\boldsymbol I-\boldsymbol b_{i+1}^{-1}\right)\end{aligned}

Therefore:

\boxed{\texttt{stiff2}\quad\text{and}\quad\texttt{stiff3}\quad\text{evaluate the same Euler\text{–}Almansi strain}}

stiff2 reaches the current Euler–Almansi strain by transporting the previously accumulated strain and the new increment, whereas stiff3 obtains the same strain directly from the total current deformation. This is an exact kinematic equivalence; it is not a claim that the complete finite-element formulation is exact.

Although stiff3 does not introduce a different Euler–Almansi strain measure, it provides an independent way of evaluating it. It avoids strain-history accumulation for current strain evaluation and provides a useful numerical verification of the transformed strain update introduced in Section 15.2.

Displacement comparison

The comparison uses only the displacement components of the node on the midline of the free-end section. This provides a clean common quantity because the implementations involve different stress descriptions. Direct MATLAB verification confirmed that the first listed displacement is $u$ and the second is $v$ ; both are negative with the adopted global axes.

The TL reference solution, obtained with $n_{\mathrm{step}}=10$ , required 63 total iterations and gave:

u_{\mathrm{ref}}=-150.21\,\mathrm{mm},\qquad v_{\mathrm{ref}}=-282.46\,\mathrm{mm}

Each cell lists the total number of iterations followed by the two signed displacement components at the midline node of the free-end section.

$n_{\mathrm{step}}$	Section 15.1	15.2 `stiff`	15.2 `stiff2`	15.3 `stiff3`
5	$n_{\mathrm{iter}}=66$ $u=-159.73\,\mathrm{mm}$ $v=-287.74\,\mathrm{mm}$	$n_{\mathrm{iter}}=40$ $u=-155.93\,\mathrm{mm}$ $v=-284.50\,\mathrm{mm}$	$n_{\mathrm{iter}}=102$ $u=-149.51\,\mathrm{mm}$ $v=-282.69\,\mathrm{mm}$	$n_{\mathrm{iter}}=102$ $u=-149.51\,\mathrm{mm}$ $v=-282.69\,\mathrm{mm}$
10	$n_{\mathrm{iter}}=86$ $u=-158.69\,\mathrm{mm}$ $v=-287.31\,\mathrm{mm}$	$n_{\mathrm{iter}}=64$ $u=-152.84\,\mathrm{mm}$ $v=-283.48\,\mathrm{mm}$	$n_{\mathrm{iter}}=106$ $u=-149.90\,\mathrm{mm}$ $v=-282.88\,\mathrm{mm}$	$n_{\mathrm{iter}}=106$ $u=-149.90\,\mathrm{mm}$ $v=-282.88\,\mathrm{mm}$
20	$n_{\mathrm{iter}}=137$ $u=-154.47\,\mathrm{mm}$ $v=-284.97\,\mathrm{mm}$	$n_{\mathrm{iter}}=111$ $u=-151.45\,\mathrm{mm}$ $v=-283.00\,\mathrm{mm}$	$n_{\mathrm{iter}}=154$ $u=-149.99\,\mathrm{mm}$ $v=-282.93\,\mathrm{mm}$	$n_{\mathrm{iter}}=154$ $u=-149.99\,\mathrm{mm}$ $v=-282.93\,\mathrm{mm}$
50	$n_{\mathrm{iter}}=267$ $u=-151.91\,\mathrm{mm}$ $v=-283.53\,\mathrm{mm}$	$n_{\mathrm{iter}}=221$ $u=-150.68\,\mathrm{mm}$ $v=-282.72\,\mathrm{mm}$	$n_{\mathrm{iter}}=300$ $u=-150.02\,\mathrm{mm}$ $v=-282.94\,\mathrm{mm}$	$n_{\mathrm{iter}}=300$ $u=-150.02\,\mathrm{mm}$ $v=-282.94\,\mathrm{mm}$

The corresponding average number of iterations per load step is:

\bar n_{\mathrm{iter}}=\frac{n_{\mathrm{iter,total}}}{n_{\mathrm{step}}}

$n_{\mathrm{step}}$	Section 15.1	`stiff`	`stiff2 = stiff3`
5	13.2	8.0	20.4
10	8.6	6.4	10.6
20	6.85	5.55	7.70
50	5.34	4.42	6.00

MATLAB validation. The current packages were executed in MATLAB R2026a using the approved convergence norm based on neq. For 5, 10, 20, and 50 load steps, both stiff2 and stiff3 required respectively 100, 104, 150, and 300 iterations. Their displacement differences were below

6.2\times10^{-5}\,\mathrm{mm}

, which is normal floating-point roundoff. The small differences between these iteration totals and the benchmark table arise from the convergence-norm normalization; the benchmark values are retained unchanged.

For $n_{\mathrm{step}}=5$ , the displacement differences relative to the TL reference are approximately 6.3% in $u$ and 1.9% in $v$ for Section 15.1; 3.8% and 0.7% for stiff; and 0.47% and 0.08% for stiff2/stiff3.

Exploratory calculations with only one to three load steps produced unacceptable displacement solutions and are therefore not included in the systematic comparison. No conclusion is drawn for four load steps.

Interpretation and conclusion

For every tested number of load steps, stiff2 and stiff3 produced identical displacement results to the reported precision and identical iteration counts. This provides a strong independent verification of the strain transformation used in stiff2.

Already with five load steps, their displacement solution is very close to the TL reference. The simple stiff update requires more load-step refinement to approach the same displacement accuracy, while Section 15.1 is still more sensitive to load-step size for this example.

Accuracy and iteration speed are different issues. The transformed/direct strain update requires more iterations per load step in this example, but substantially fewer load steps are needed to obtain an accurate displacement solution.

The larger number of iterations required by stiff2 and stiff3 is consistent with the use of an approximate tangent stiffness together with the corrected strain evaluation. The tangent primarily affects the convergence path and convergence rate; the equilibrium condition is governed by the internal-force vector. This is an observation for the present implementation, not a general statement that an approximate tangent always produces this behavior.

The direct strain evaluation eliminates strain-history accumulation from the Euler–Almansi calculation, but the complete nonlinear finite-element solution may still depend slightly on the load-step discretization because the remaining algorithmic approximations are unchanged.

The three UL implementations illustrate progressively different ways of treating strain updates. The direct Euler–Almansi evaluation in stiff3 eliminates the need to accumulate strain history for the purpose of evaluating the current strain. Its complete numerical agreement with stiff2 confirms that the tensor transformation introduced in Section 15.2 reproduces the same Euler–Almansi strain obtained directly from the total current deformation.

For the present example, this more accurate strain treatment requires more iterations per load step than the simple stiff update, but it reaches an accurate displacement solution with substantially fewer load steps.

Program and download

A MATLAB program package for the direct stiff3 implementation can be downloaded below.

MMATLAB packageDownload ZIP