WorksMathematics
Mathematical analysis and vectorized FEM implementation of logarithmic strain space framework for finite strains: a case study on elastoplasticity
Abstract
We investigate the mathematical and computational aspects of the logarithmic strain space framework for finite-strain models in nonlinear continuum mechanics, focusing on the classical von Mises elastoplastic model with linear kinematic hardening. To overcome the lack of coercivity and lower-semicontinuity in the quadratic Hencky energy, we introduce higher-gradient regularization and prove the existence of energetic solutions for rate-independent quasistatic evolution under time-dependent Dirichlet loading. Complementarily, we develop a vectorized MATLAB finite-element implementation of the framework leveraging page-wise matrix functions and operations, and our custom vectorization library. Computational benchmarks show that local tensor operations are significantly accelerated, the logarithmic-strain approach does not substantially increase computational costs, and the implementation robustly handles large rotations and deformations.
Introduction
Finite strain models of materials are essential in engineering since they allow us to analyze the mechanical response of structures or components experiencing large displacements, rotations, or geometric changes. The relationship between stress and strain then becomes highly nonlinear, and the classical small strain theory no longer applies. The logarithmic strain space approach developed by Miehe, Apel and Lambrecht in [1] is a well-established route for accomplishing the transition from a linear constitutive model to a nonlinear one. In the original paper, the theory was applied to the classical small-strain plasticity, but it was later successfully employed for the development of finite-strain models of thermoviscoplasticity [2], gradient plasticity [3, 4, 5], gradient-enhanced damage–plasticity [6, 7, 8], or, recently, martensitic phase transformations [9, 10]. The main appeal lies in its modularity, allowing constitutive structures of geometrically linear models to be incorporated into the logarithmic strain space, accompanied by pre- and postprocessing phases that are purely geometric and independent of the constitutive structures themselves. This brings significant benefits for the implementation of such constitutive models into the finite element method (FEM), which is the key instrument for computational structural analysis in engineering.
Although this flexible approach is frequently adopted and implemented in finite element codes, rigorous mathematical existence theories for the resulting additive logarithmic-strain models are much less developed. This is largely because the elastic energy inherited from their linear constitutive siblings is generally neither polyconvex nor quasiconvex and lacks the standard coercivity properties (used in nonlinear elasticity). From the algorithmic standpoint, working in logarithmic strain space requires the computation of generalized logarithmic strain tensors and the corresponding transformation tensors. This entails repeated evaluations of matrix logarithms (see, e.g., [11, 12]) and spectral decompositions, and the use of nested loops for repeated computations on objects arising from finite element discretization, which brings an additional computational burden. Over the past two decades, vectorization techniques have been developed to make the operations on large vectors, matrices, or tensors more efficient. However, to the best of the authors’ knowledge, a comprehensive algorithmic framework dealing with the numerical aspects of the FEM implementation of the additive logarithmic-strain approach in a concise and unified manner has not been presented yet.
To fill these gaps, the present work provides mathematical analysis and a vectorized FEM implementation of a finite strain version of von Mises elastoplasticity with linear kinematic hardening. The particular choice of the constitutive model was motivated by our aims stemming from applied mathematics and computational practice: it has a sufficiently simple and well-known constitutive structure that allows us to focus on the mathematical and numerical treatment of the model, yet it features the material nonlinearity typical of many real engineering materials; hence, the main challenges for mathematical analysis are preserved, and the constitutive core can still serve as a useful template for applying the approach to more complex material models.
Hence, as the first contribution of the present work, we provide a mathematically rigorous analysis of a suitably regularized version of the model and prove the existence of energetic solutions under time-dependent Dirichlet loading. To overcome the mathematical issues raised above, we employ powerful tools from the calculus of variations, which are now able to treat quasistatic evolutionary problems as well (e.g., [13, 14]) and resort to gradient regularization, where the stored energy density also depends, e.g., on the gradients (of various orders) of the deformation and/or internal variables. Mathematically, this ensures model compactness, which is essential for proving the existence of solutions via the direct method [15]. Such a constitutive material law, referred to as non-simple, was first introduced by Toupin [16] and has since been extensively developed, e.g., [17, 18, 19, 20].
As the second main contribution of this work, we develop, describe, and implement a fully vectorized version of the finite strain model in the MATLAB computational environment. In scripting languages, explicit loops over all elements, nodes, or quadrature points of a FEM geometric discretization are typically computationally expensive. By exploiting efficient implementations of linear and multilinear algebra, vectorization techniques enable replacing such loops with operations on large vectors or matrix-like objects (called arrays in MATLAB). The gain in computational efficiency (related to, e.g., elimination of interpreter overhead, exploiting optimized libraries and efficient processor and cache utilization) generally comes at the expense of increased memory consumption. Vectorization techniques have been successfully applied to second-order linear partial differential equations; see, for example, [21, 22, 23], as well as to selected nonlinear problems [24, 25]. They have proved particularly effective in finite-element assembly. Vectorized assembly procedures have been developed for standard P1 finite elements [26, 27], edge elements [28], primal hybrid finite elements [29, 30], and higher-order adaptive finite elements [31], among others. A general vectorization framework applicable to several programming languages was presented in [32]. Here we combine vectorization strategies at both the global and local levels of the assembly process. We also benefit from vectorizing numerical spectral decomposition recently introduced in MATLAB. This eliminates the need for analytical eigenvalue calculations based on Cardano’s formulas, which are known to suffer from numerical instability when eigenvalues coincide or are close to one another, which may happen in continuum mechanics.
The paper is organized as follows. § 2 introduces the weak formulation of the quasistatic elastoplastic boundary value problem and summarizes the methodology of the logarithmic strain space approach presented in [1]. This is employed in § 3 to formulate the boundary value problem for von Mises elastoplasticity with kinematic hardening in the logarithmic strain space. We also focus on its mathematical analysis there – we define the energetic solution concept in the spirit of [33], and we discuss the main pitfalls of the additive logarithmic strain formulation with respect to this concept. § 4 covers the problem’s discretizations, introduces the general computational scheme, and briefly summarizes the backbone of the FEM code developed in [24]. The particular, fully vectorized FEM implementation obtained by extending that code is described in § 5. In this respect, we employ the vectorized linear algebra framework described in [34], whose development has benefited from implicit expansion and page-wise matrix operations in MATLAB. We provide details on the algorithmization of all new features, including the MATLAB code, which is also available for free download from a code repository [35]. Finally, we assess the performance of the vectorized code and demonstrate its computational capabilities on two real-world inspired examples in § 6.
Additive Lagrangian approach to finite plasticity developed by Miehe and coworkers
In this section, we briefly introduce the elastoplastic quasistatic boundary value problem and logarithmic strain space approach for finite plasticity developed in [1]. We summarize the main facts and refer the reader to the dedicated literature for details.
Quasistatic boundary value problem of elastoplasticity
Let us consider a quasistatic, i.e., inertia effects not considered, mechanical problem of a homogeneous solid body occupying a domain . Its Lipschitz boundary is decomposed as , where and are open and disjoint. A prescribed displacement function specifies the Dirichlet boundary conditions on . We denote the unknown displacement field by and the space of suitable test functions vanishing on by . The general loading consists of prescribed volume forces in and surface tractions on .
For implementation in FEM, the principle of virtual work (the weak form of the momentum balance) is essential. Denoting by the current counterparts of the objects defined above in the reference configuration, we can formulate the virtual work principle in the current configuration as
Above, denotes the Cauchy stress tensor, and
is the (infinitesimal) strain tensor. Both tensors are functions of the displacement gradient. The additional dependence of on the internal field (or even a set of internal fields) allows dealing with nonlinear path-dependent material response via the so-called internal state variables theory, e.g. [36, 37, 38]. Indeed, in many engineering situations, the material response is not only nonlinear (as, e.g., in hyperelasticity), but also path-dependent; hence, the constitutive relation also depends on internal variables (and even on their gradients) that capture the material’s microstructural evolution and influence the (total) macroscopic strain. Omitting the dependence on in (1) would lead to the conventional elasticity instead.
Hence, the model must be completed by specifying the constitutive response, i.e., by recovering stress from the (work-conjugate) current strain, , and its history encompassed in the internal variable field denoted by . In the small-strain approximation, the additive decomposition of strains,
is a highly useful assumption that has enabled engineers to construct a wide range of constitutive relations. A typical example is von Mises elastoplasticity, where the internal variable, , captures the evolution of plastic flow in the material at higher stress; see Appendix § 12.§ 1. More details on the conceptual numerical framework for the small-strain setting, which served as a starting point for the developments below, can be found in [24].
When the geometric nonlinearities also come into play, we can reformulate the momentum balance in the reference configuration in terms of the first Piola–Kirchhoff (nominal) stress tensor, , which is work-conjugate to the deformation gradient,
and . The total Lagrangian formulation of the weak problem (1) in the reference configuration, , then takes the form
Considering again a suitable strain tensor, , and some internal variable, , capturing the material nonlinearities (see (7) and (15) below), the tensor can be recognized as a stress-displacement operator emphasizing the implicit dependence of the first Piola stress on the internal variable(s) in case of internal state variable theory. Such a situation will be treated in the rest of the paper.
Now, the situation is more difficult, since the additivity assumption similar to (3) is generally invalid and constructing models with some (inelastic) contribution to the total deformation is not straightforward. Indeed, even for the family of plasticity models with one internal variable representing the plastic strain, many approaches can be found in the literature [39, 40, 41, 42, 43, 44, 45, 46]. One of the popular ones is the logarithmic strain approach formulated in a FEM-convenient modular way in [1].
Construction of finite strain models via the logarithmic strain approach
The approach for a simple, algorithmically smooth transition from a small-strain model towards a finite strain formulation was originally developed by Miehe et al. [1]. The main advantage is that it does not require substantial modifications to the constitutive core; instead, it extends the original computational workflow with preprocessing and postprocessing phases. The key idea is that the original constitutive algorithm operates on objects defined in the logarithmic strain space, and the transformations in the pre- and postprocessing phases link them to the weak formulation (5); see [1] for the theoretical underpinnings.
Figure 1 shows the brief scheme of finite element data flow for an initial boundary value problem. The upper process diagram shows the situation for a constitutive model formulated in the small-strain realm, with (possibly a set of) internal variables enclosed by curly brackets, . In such a situation, the current and the reference configurations coincide, hence we omit the notation for brevity. The lower diagram shows the modifications made to adopt the logarithmic strain-space approach fitted to the weak formulation (5). In the preprocessing phase denoted (A) (cf. Figure 2), the logarithmic strain measure, , is computed from the displacement field, , via the deformation gradient, . Then, this strain measure and internal variables enter the constitutive law, which may retain the identical structure as in the small-strain formulation. It provides the generalized stress tensor, , and the algorithmic stiffness tensor (also called consistent tangent modulus), , marked as (B). In the postprocessing phase, (C), these are transformed into the first Piola–Kirchhoff stress measure, , and the corresponding algorithmic stiffness tensor, . The postprocessing transformation is purely geometrical and uses specific projection tensors. Other computational procedures from the original small-strain model – such as handling internal variables or resolving the constitutive response (time discretization and state updates) – remain unchanged.

Figure 1. Schematic comparison of the data flow for constitutive models within the conventional small-strain (top) and the logarithmic-strain (bottom) computational frameworks. Inputs to the constitutive model are on the left of the central box, and outputs on the right. Symbols (A), (B), and (C) over the arrows denote the preprocessing, constitutive update, and postprocessing phases referred to in Figure 2, respectively.

Figure 2. Computational scheme for the solution of the logarithmic strain version of the von Mises elastoplastic boundary value problem with the finite element method.
In line with the original paper [1] and with respect to clear and direct communication of the mathematical and numerical advances, we focus our study on the von Mises elastoplastic model with linear kinematic hardening of Prager type, so that the only internal variable considered in the small-strain model is identified as the plastic strain tensor, . We refer readers to the Appendix § 12.§ 1 for a brief summary of this model. However, as documented by a rich literature [5, 7, 2, 10], the framework a priori does not constrain the type and number of internal variables. Hence, in principle, the curly brackets in Figure 1 could contain more internal state variables of various types (scalars, tensors, etc.) if additional features are to be captured in the model (e.g., isotropic hardening, damage, phase transition), provided their transition to the logarithmic space is properly treated.
Below, we provide an overview of the key tensorial quantities used to extend the model to finite strains, following the approach illustrated in Figure 1. The complete model is presented in the next section. The (Lagrangian) right Cauchy–Green tensor, , is resolved from the deformation gradient introduced in (4), as
The logarithmic (Hencky) strain, , takes the form
Defining the transformation tensors (4th order) and (6th order) as
allows us to recover the first Piola–Kirchhoff stress, , as
and the consistent tangent modulus , as
which are cornerstones for the postprocessing phase. Let us also recall the relation between and the second Piola–Kirchhoff stress
and the Cauchy stress
The original formulation for metal plasticity models is motivated by the equivalence between multiplicative decomposition of the total deformation gradient and additive decomposition of logarithmic Lagrangian strain in the case of coaxial total and plastic deformations [1]. In the paper, the authors also showed reliability and effectiveness for anisotropic plastic response. Let us note that for metals and alloys, we can usually assume that the elastic strain is much lower than the total strain when plastic flow occurs. In [47], the authors compared computational results from the multiplicative decomposition-based formulation and the logarithmic strain-based formulation of elastoplasticity with nonlinear isotropic hardening. It was found that “the combination of large elongations and large shearing results in a significant difference in results”. However, the majority of the problems outlined in the paper “are not dominant or decisive in practical simulations.” The deviations were attributed to the mathematical properties of the model, namely the loss of ellipticity in the logarithmic strain space approach, cf. also [48]. The related mathematical issues are discussed in the next section.
Formulation and mathematical analysis of the von Mises elastoplastic problem with kinematic hardening in the logarithmic strain space
Additive von Mises elastoplasticity with linear kinematic hardening in the logarithmic strain space
Motivated by the conventional (rate-independent) von Mises elastoplasticity model summarized in Appendix § 12.§ 1 and by the framework of [1] presented in the previous section, we formulate the logarithmic strain-space adaptation of the model to the finite strain regime. Loosely speaking, this can be accomplished by the following purely formal substitutions in relations in Appendix § 12.§ 1:
with material parameters retained, and complemented by the relations from § 2.2.
In a more formal way, we first recall that the Lagrangian logarithmic (Hencky) strain is
and we define the plastic variable
where denotes the space of symmetric matrices and
is its subspace of trace-free (deviatoric) matrices; the trace-free constraint expresses plastic incompressibility, see below. The variable is interpreted as the logarithmic plastic strain. Let us note that the plastic metric can be reconstructed simply as ; see [1] for details.
Consider for a moment the multiplicative decomposition of the deformation gradient into an elastic part, , and a plastic part, , as . Under the assumption of co-axiality of and , one gets from (14)
To arrive at a computationally attractive framework, the logarithmic strain approach in [1] assumes the approximate validity of this relation beyond the coaxiality assumption.
Hence, we define the elastic logarithmic strain as
Such a formulation is particularly attractive because the plastic variable belongs to the linear space , and plastic incompressibility
is represented by the (computationally much simpler) linear constraint
The (volumetric) free-energy density of the material is then given by
with and being the conventional elastic stiffness tensor and the kinematic hardening coefficient, respectively. The generalized thermodynamic forces (in the logarithmic space) take the standard form
Here, is the logarithmic stress, is the backstress in the logarithmic strain space, and is the relative stress (the force driving the dissipation).
The classical yield condition and flow rule (i.e. the relation between the generalized forces and fluxes/velocities) can be equivalently reformulated [49] in terms of the dissipation (pseudo)potential
where denotes the (constant) yield stress, together with a thermodynamic selection criterion, which can be loosely stated as a minimization problem
Formulation (25) is called the minimum principle of dissipation potential in [50]. Its discretized version, the incremental energy minimization principle, is common in mechanics of materials [13, 51, 52, 53], and for the model at hand provides the same governing equations as the principle of maximum dissipation; see details in [50]. It also perfectly fits into the mathematical theory of energetic solutions [33], which is applied below.
Regularized boundary value problem with time-dependent Dirichlet data
Let us first recall why a rigorous treatment of the boundary value problem requires some care. In nonlinear elasticity, the existence of equilibria is usually proved by the direct method of the calculus of variations: one minimizes the stored energy over admissible deformations, which requires coercivity of the energy, so that minimizing sequences are bounded in a suitable Sobolev space, and weak lower semicontinuity of the energy along such sequences. For integral functionals of the deformation gradient, weak lower semicontinuity is essentially equivalent to the quasiconvexity of the stored energy density in the sense of Morrey [54]. Convexity in is too restrictive, since it is incompatible with frame indifference and with the blow-up of the energy as , while quasiconvexity is very difficult to verify. Ball [55] therefore introduced polyconvexity, i.e., convexity of the energy as a function of , its cofactor matrix and its determinant. Polyconvexity is easy to check; it is compatible with the blow-up as , and together with a simple coercivity condition on the stored energy density (cf. (27) below) it guarantees the existence of minimizers.
For rate-independent processes such as elastoplasticity, a natural notion of weak solution is that of an energetic solution [56, 33], which is defined by a global stability condition and an energy balance, see below, and does not require any differentiability of the energy with respect to the state. Energetic solutions are constructed from the time-incremental minimization problems, i.e., from the incremental energy minimization principle mentioned above. Each incremental problem is a minimization problem to which the direct method applies under the same coercivity and lower semicontinuity requirements as in elasticity, and the limit of vanishing time steps is obtained from uniform energy estimates and compactness arguments [57, 56]. For finite-strain plasticity based on the multiplicative decomposition, this program has been carried out in [14, 58, 19], where gradient terms of the plastic variables provide the necessary compactness.
In the logarithmic strain framework, the plastic variable takes values in the linear space , and the dissipation, the kinematic hardening energy and the gradient term of introduced below are convex. Hence, the plastic part of the problem does not create any difficulty. The main difficulty lies instead in the deformation variable. Even for fixed , the map
is not, in general, polyconvex or quasiconvex [55, 54]. Consequently, the direct method of the calculus of variations does not yield existence of a minimizer without regularization. This issue is already emphasized by Miehe, Apel, and Lambrecht in [1], who note that their logarithmic-strain framework is not polyconvex in the elastic range and that existence of global incremental minimizers is therefore not guaranteed for arbitrary elastic strains.
There also a coercivity issue. A purely quadratic Hencky energy, for example
grows only logarithmically in the singular values of , see the definition (14). Thus, one cannot expect a standard bound of the form
with constants and some exponent . This is why we introduce regularizing gradient terms multiplied by a “small” parameter in (34) below. This allows us to obtain both coercivity and compactness and, finally, the existence of an energetic solution for the corresponding rate-independent evolution. Another approach to these issues was considered in [59].
Let be a bounded domain and let have positive surface measure. For simplicity and with respect to simulations in § 6, let us consider the only external loading given through a time-dependent Dirichlet boundary condition. For , let
be an orientation-preserving diffeomorphism1, and prescribe
Following the composition approach for time-dependent boundary conditions, we write
and impose the fixed boundary condition
Define
The corresponding total logarithmic strain is
Choose constants , , , , and . We define the regularized energy by
To avoid , we set
whenever on a set of positive measure. (35)
The admissible state space is
Let also the dissipation potential be convex, positively one-homogeneous, and satisfy
We define the dissipation distance between two states and as
Energetic formulation
A pair is called an energetic solution [33] if, for every , it satisfies the global stability condition
for every admissible competitor , and the energy balance
Here, , where the supremum is taken over all partitions , is the total dissipation on . The integral on the right-hand side represents the work induced solely by the time-dependent Dirichlet boundary condition. Namely, at fixed , define . Since , we have
The stability condition can be interpreted as: there is no admissible change of state whose energetic gain is larger than the dissipation needed to perform that change. Let us note that the current state is compared with every admissible competitor, not only with infinitesimally close states.2 The energy equality is easy to interpret: all work done by external loads is spent either on dissipation or stored in the material.
We formulate and prove the theorem which establishes the existence of an energetic solution to the regularized model in Appendix § 12.§ 2. In § 6, we carry out numerical simulations to illustrate the advantage of the modularity of the logarithmic strain framework. We directly adopt the standard formulation of the elastoplastic model from [24], which corresponds to setting in (34), i.e., we neglect the higher-order regularization. This significantly simplifies the code; e.g., it permits avoiding higher-order approximation of the plastic strain variable in the FEM implementation. However, strictly speaking, the existence or convergence of such an unregularized model is not covered by the theorem. A detailed discussion is left to Appendix § 12.§ 2.
Discretizations and algorithmic setup
The standard tool for the numerical solution of boundary value problems (5) is the finite element method (FEM) [60, 61, 62]. The weak (variational) formulation of the problem is restricted to a finite-dimensional space of piecewise polynomial functions defined on a mesh, i.e., on a partition of the body into simple elements (in this paper, hexahedra with trilinear shape functions), and the unknowns are the nodal values of the displacement field. In elastoplasticity, the FEM is combined with a discretization in time, so that at every time step of a nonlinear algebraic system has to be solved, while the internal variables are updated locally at the quadrature points of the elements by a return-mapping algorithm [63, 49].
Temporal and spatial discretizations of the initial boundary value problem in the weak form
The time-discretization leads to a generic time-incremental (rate-independent) problem
The operator encompasses the implicit dependence on the internal variable , which is, however, resolved via the constitutive core (cf. (25)) based on the value of , too. Finally, we perform the spatial discretization of the time-discretized problem (41). Together with the time incrementation of the time interval , we obtain the problem in the form:
where from (44) is a finite-dimensional approximation of , see (43) below, and , , and are suitable approximations of , , , and , respectively.
Finite element discretization and formulation of the algebraic problem
In order to solve (42), we employ FEM for the spatial discretization; an overview of related indexing system and the notation is in Table 1. Let denote a partition of the computational domain into closed hexahedral elements. On this mesh, we use trilinear Q1 finite elements in the sense of Ciarlet [60].3 Each element is geometrically defined by its eight vertices, which belong to the global set of mesh nodes .
| Symbol | Description |
| Index of a global node or basis function () | |
| Spatial component indices () | |
| Element index () | |
| Index of a local node or basis function () | |
| Local quadrature-point index () | |
| Discrete time-step index | |
| Newton’s method iteration index | |
| Set of elements (computational mesh) | |
| Total number of elements | |
| Set of mesh nodes | |
| Total number of nodes (global scalar nodal basis functions) | |
| Total number of boundary faces | |
| Reference element | |
| Number of nodes (local scalar basis functions) per element | |
| -th local node of the -th element | |
| Number of quadrature points per element | |
| Total number of quadrature points () | |
| -th quadrature point of the reference element | |
| -th quadrature point of the -th element | |
| -th basis function of the reference element | |
| -th local basis function of the -th element | |
| -th global basis function |
Table 1. Indices and notation used in the finite element discretization.
We consider a test function and a test space (in three dimensions) of the form:
Denote by the full scalar trilinear finite-element space, including basis functions associated with the Dirichlet boundary, and set , , where denotes the discrete Dirichlet boundary for the -th displacement component. We then approximate in the finite-dimensional subspace
The full scalar finite-element space is spanned by the global Lagrange basis functions
such that
where denotes their number (equivalent to the number of mesh nodes). Homogeneous Dirichlet conditions are imposed by setting the coefficients associated with constrained displacement components to zero. Hence, any component of is given by a linear combination
By we denote the -th local basis function on the -th element, which is the restriction of the corresponding to
where is the standard local-to-global index map.
We consider a reference element with vertices
and denote its local coordinates by . Then, any element , , is given by the isoparametric mapping, , between and defined by
where denotes the -th node of the -th element of and is the -th local basis function on . Using (50), for any we obtain the following relation:
To compute the volume integrals in (42) numerically, we employ the following transformation formulas [62]
and consider a numerical quadrature [62] in in the general form:
where denotes the integrand, are the quadrature points inside , and are the corresponding weights. Then, one can derive the following formula:
where are the quadrature points of given by the transformation (50) and is the corresponding Jacobian matrix on . Using (50), it can be expressed as
where and index the physical and reference coordinates, respectively, and is the -th coordinate of node . Using (50) and (52), we obtain the following formula for the partial derivatives of local basis functions on the whole :
Similarly, the Gauss quadrature rules can also be applied to surface integrals, which can appear, for example, when Neumann boundary conditions are prescribed. Further technical details can be found in [24].
Passing from one element to the whole computational mesh, we form an ordered list of all mesh nodes as a vector . Now the function may be represented by the vector
which belongs to the space
where is the index set of prescribed displacement degrees of freedom, and the constraints defining impose the corresponding homogeneous Dirichlet boundary conditions.
To express from (42) in algebraic form, we introduce the nodal vectors and associated with and , respectively. The external and internal force vectors are specified through their action on the test vector :
Consequently, the problem has the following algebraic form:
Eliminating the rows associated with prescribed displacement degrees of freedom reduces to the following system of nonlinear equations:
where and contain the components of and corresponding to the unconstrained degrees of freedom. We solve this discrete problem using the semismooth Newton method. For this purpose, we define the tangent matrix associated with a generalized derivative of at :
where represents a generalized (Newton) derivative of in the sense of semismooth Newton methods, given at the integration points by the consistent tangent modulus from (10). Its preimage in the logarithmic space, , coincides with the elastic stiffness for elastic response and is replaced by the elastoplastic tangent whenever plastic yielding is active; its closed form can be found in [24]. At each Newton iteration, we solve a linear system with the reduced tangent stiffness matrix , obtained by retaining only the rows and columns associated with unconstrained degrees of freedom:
with denoting the current time step and denoting the current iteration. Here, contains all displacement components, including the prescribed values, whereas contains only the increments of the unconstrained degrees of freedom.
Algorithmic setup
The complete numerical implementation can be described by the algorithmic setup summarized in Figure 2. The computational core (denoted 2.) consists of an outer time-stepping loop in which, at each time step, new displacements are computed together with an inner while-loop arising from Newton’s method. A single Newton iteration requires the assembly of the global tangent matrix , which involves the evaluation of all quantities introduced in this text. In practice, this is typically performed within an inner for-loop iterating over the quadrature points of all elements of .
MATLAB implementation
Our MATLAB implementation follows the scheme in Figure 2. We build on the FEM tool introduced in [24], whose capabilities have been continuously enhanced, expanded, and streamlined [64, 65, 66]. Below, we will detail some crucial parts of our modified code. In the first stage (1. Generating FEM assemblies), we follow the approach in [24] except for a slightly modified construction of the displacement-gradient matrix, described in § 5.4.
Details on the second stage (2. Main computational procedure – time stepping), which brings the main novelties of this work – i.e., the logarithmic space approach, its vectorization, and details on integration into the workflow – are presented in subsequent parts of this section. But first we specify the data storage and vectorization libraries we use.
Preliminaries
To fully exploit the advantages of vectorization techniques in MATLAB, it is often beneficial to reduce the dimensions of some objects or to produce a multidimensional object. As for the first situation, second-order tensors are in some cases represented by vectors containing their independent components. In such a case, our implementation operates with the Voigt notation to represent a symmetric second-order tensor () via the corresponding vector
Generating FEM assemblies (mostly adopted from [24]): (i) Discretization of the computational domain into elements, (ii) Computing the values of the local basis functions and their derivatives at the Gauss (integration) points, computing element volumes, etc. (iii) Assembling the displacement-gradient matrix using (68), (iv) Assembling the global elastic stiffness matrix .
Main computational procedure – time stepping (For-loop): (i) Setting the boundary conditions (including vector ) and adjusting the initial displacements , (ii) Iterating via Newton’s method for solving a nonlinear system (While-loop): (A) Preprocessing phase: (a) Determining from and computing according to (6), (b) Computing the eigenvalues and eigenvectors of and then recovering from (7), (B) Constitutive update phase (resolution of the constitutive problem) providing and , (C) Postprocessing phase: (a) Computing the transformation tensor from (8) and the product , (b) Recovering stress and tangent modulus from (9) and (10), respectively, (D) Assembly of the internal force vector and global tangent matrix utilizing and , (E) Solving (64) for the displacement increment and updating the nodal displacement vector , (F) Checking the convergence of Newton’s method via (75). (iii) Updating the data and continuing to the next time step.
Data storage and visualization.
(or vice versa)
This also motivates the ordering of the vectors representing non-symmetric second-order tensors () as follows
Moreover, modern vectorization tools allow performing matrix operations on a set of matrices simultaneously through multidimensional arrays, i.e., “stacks” of matrices. Hence, for instance, the set of (symmetric) logarithmic stress tensors at all integration points is stored both as a “stack” of vectors (i.e., MATLAB 2-D array denoted Si) for computing the constitutive response and as a “stack” of matrices (i.e., MATLAB 3-D array denoted Si_3D) for the tensor operations in the postprocessing phase. Table 2 provides an overview of the main quantities used in the model together with their counterparts in MATLAB.
| Quantity | Symbol | MATLAB variable | Array size |
| Nodal displacements | U | ||
| Displacement-gradient matrix | B | ||
| Elastic stiffness matrix | K_el | ||
| Deformation gradient (4) | F | ||
| F_3D | |||
| Right Cauchy–Green tensor (6) | C_3D | ||
| Eigenvectors of | eVec_3D | ||
| Eigenvalues of (diagonal matrices) | eVal_3D | ||
| Logarithmic (Hencky) strain (7) | E | ||
| E_3D | |||
| Logarithmic stress tensor (Fig. 1 and (21)) | Si | ||
| Si_3D | |||
| Consistent tangent modulus (Fig. 1) | DSi | ||
| Plastic strain (Fig. 1) | Ep | ||
| Transformation tensor (8) | PP_3D | ||
| Tensor contraction in (8), (10) | SiLL_3D | ||
| Consistent tangent modulus (10) | DP_3D | ||
| First Piola–Kirchhoff stress (9) | P | ||
| P_3D | |||
| Nodal internal forces | g | ||
| Nodal external forces | f | ||
| Global tangent stiffness matrix | K_tan | ||
| Second Piola–Kirchhoff stress (11) | S_3D | ||
| Cauchy stress (12) | si_3D |
Table 2. The overview of model quantities, their symbols, corresponding MATLAB array names and sizes. Both eigenvalues and eigenvectors are stored as 3-D arrays only.
The assembly procedures for most quantities associated with the mesh and the finite element discretization are adopted from [24]. In particular:
COORD – a matrix of nodal coordinates;
ELEM – an matrix containing the global indices of the nodes of each element, representing the local-to-global mapping from (48);
SURF – a matrix containing the global indices of the nodes of each boundary face;
HatP – a matrix of values of basis functions, , at the quadrature points of , cf. (50) and (51);
DHatP1, DHatP2, DHatP3 – matrices of the partial derivatives of basis functions, , at the quadrature points of the reference element, , cf. (50) and (51);
DPhi1, DPhi2, DPhi3 – matrices of the partial derivatives of local basis functions at all quadrature points of , cf. (56);
DET – determinants of Jacobian matrices, , at all quadrature points of , cf. (55).
Vectorization libraries
Our MATLAB implementation benefits from the vectorization techniques from [34] for most algebraic operations between 3-D arrays of matrices, which allows us to avoid time-consuming for-loops mostly over quadrature points; such a form of data storage is denoted by suffix _3D in the implementation. The origins of the implementation date back to the FEM assemblies for nodal [27] and edge [28] elements. Some original library functions were optimized due to the implicit (also called arithmetic or broadcasting) expansion feature that MATLAB came with in R2016b. Later, an additional speedup was achieved due to new page-wise functions introduced in MATLAB releases from 2020 to 2023, which paved the way for new vectorized FEM implementations (e.g. [67]); pagetranspose – page-wise matrix transposition (since R2020b)
pagemtimes – page-wise matrix multiplication (since R2020b)
pagemldivide – page-wise left matrix divide for solving linear systems (since R2022a)
pageeig – page-wise spectral decomposition of square matrices (since R2023a)
In particular, the last one provides a significant speedup for the preprocessing part (§ 5.4), as will be documented on the computational-time comparison plots in § 6.1. In our MATLAB implementation, we heavily employ the following functions based on the libraries developed in [27] and [34]:
amt – page-wise transposition of an array of matrices,
amdet – page-wise determinant calculation of an array of square matrices,
amtam – page-wise multiplication of the transposed array of matrices with another array of matrices,
amamt – page-wise multiplication of an array of matrices with an array of transposed matrices,
asam – page-wise multiplication of an array of scalars and an array of matrices,
In the current work, we extended the library with the following function:
amam – page-wise multiplication of two arrays of matrices.
Boundary conditions and time stepping
After establishing the objects needed for the finite element method, the boundary conditions are imposed. As in the original code, the (possibly non-uniform) time discretization is defined by prescribing the vector of time steps.4 The prescribed non-homogeneous Dirichlet and Neumann boundary conditions are discretized as well, hence, the vector of external forces, , for each step can be assembled. For effective speed-up, the initial guess of the displacement vector, , in the non-prescribed degrees of freedom is based on a combination of extrapolation from previously converged solutions and purely elastic response for the first few steps.
Preprocessing
Given a matrix of all displacements, , from the preceding parts of the algorithm, we sequentially compute:
a deformation gradient matrix, , of size in the Voigt notation at all quadrature (integration) points in all elements, and its 3-D version of size ;
a 3-D array of right Cauchy–Green tensor, , of size using
amtamfunction;3-D arrays
eVal_3D,eVec_3Dof size of the corresponding eigenvalues (in the form of a diagonal matrix) and eigenvectors of using thepageeigfunction;a 3-D array of Hencky strain, , of size containing logarithmic strains using (7) and
amamt,amamfunctions.
Concerning , given nodal displacements, we need to compute the deformation gradients at all integration (quadrature) points of each element. The crucial part is the construction of displacement-gradient matrix, . We employ the vector representation of tensors, and for one integration point at one particular element we get the relation
with being the value of the -th partial derivative of the -th local basis function at the -th integration point of the -th element.
For the entire computational mesh, a (sparse) global displacement-gradient matrix, , of size has to be assembled. It can be expressed as a block matrix with blocks , , , , as follows:
with being the value of the -th partial derivative of the -th global basis function at the -th quadrature node of the -th element. If the -th node is not adjacent to the -th element, then and its derivatives vanish in all quadrature points of , and therefore is a zero matrix. Code block 1 shows the algorithmization of the preprocessing part (denoted (A) in Fig. 2).
% deformation gradients (matrix)
F(:) = B*U_it(:); % 9 x nint
F = F + [1 1 1 0 0 0 0 0 0]';
% deformation gradients (3-D array)
F_3D = reshape(F(inds_Voigt,:),3,3,n_int); % 3 x 3 x nint
% right Cauchy-Green tensors (3-D array)
C_3D = amtam(F_3D,F_3D); % 3 x 3 x nint
% spectral decompositions of ’C’ (3-D arrays)
[eVec_3D,eVal_3D] = pageeig(C_3D); % (for one slice, C = eVec*eVal*eVec’)
eVal_ln_3D = eVal_3D; % 3 x 3 x nint
eVal_ln_3D(inds_diag) = log(eVal_3D(inds_diag)); % applying logarithm elementwise to the diagonals
% logarithmic (Hencky) strains (3-D array)
E_3D = amamt(amam(eVec_3D,eVal_ln_3D),eVec_3D)/2; % 3 x 3 x nint
% logarithmic (Hencky) strains (matrix)
E = reshape(E_3D,9,[]);
E = E([1 5 9 8 7 4],:).*[1;1;1;2;2;2]; % 6 x nint
Code Block 1: Vectorized assemblies in the preprocessing part.
Constitutive update
The main benefit of the logarithmic strain approach is its modular nature, which allows for a complete adoption of the constitutive update algorithm used in the small-strain formulation. Hence, the elastoplastic update algorithm from [24] (corresponding to the non-regularized constitutive model from § 3) can be directly incorporated. Just the internal variable arrays are now interpreted as the logarithmic plastic strain, , and as an auxiliary variable related to the logarithmic back stress, , imposed by kinematic hardening; cf. (22). Let us note that isotropic elasticity is considered; hence, the elasticity tensor is recovered from only two independent elastic parameters.
The employed constitutive model allows a closed-form, fully vectorized implementation; hence, the constitutive update is resolved for all integration (material) points simultaneously. Note, however, that this might not work for some other constitutive models, where the iterative process is employed, e.g., our recent work [10]. Code block 2 shows the constitutive function call with updated names of input and output variables.
[ Si , DSi , IND_p , Ep , Hard ] = constitutive_problem (E , Ep_old , Hard_old , shear , bulk , a , Y) ;
Code Block 2: Vectorized constitutive update function call.
Postprocessing
The postprocessing part of the algorithmic workflow in Figure 2 uses the transformation tensors and from (8). is used to compute both the first Piola–Kirchhoff stress, , from (9) and the consistent tangent modulus, , from (10), while only appears in the assembly of in the tensor contraction . Since some auxiliary variables appear in both assemblies of and (described in detail in Figure 3 and adopted from [1]), we assemble them simultaneously in the assembly_PP_SiLL function, see also Code block 4 in Appendix § 12.§ 3. These assemblies are rather technical and include evaluation of (up to three-level) nested for-loops, where the indices of the inner loops depend on the indices of the outer ones. Therefore, vectorization of this part requires special treatment, where logical vectors inds1, . . . , inds5 are used to distinguish between different cases of eigenvalue (in)equality (see part 2. in Figure 3). These are consequently used in the final assemblies of and , stored as three-dimensional arrays (for all integration points of ), where the amam, amtam, asam, and amt functions listed in Subsection 5.2 are utilized.

Figure 3. Spectral decomposition and construction of projection tensors for the preprocessing and postprocessing phases used in our code. The constant standard (Cartesian) metrics are considered. Adapted from [1].
Since we are employing the first Piola stress in the virtual work principle (5) and working in the Cartesian metric, the left term of the Kronecker product
from the assembly of in the last relation in Figure 3 condenses merely to the second Piola–Kirchhoff stress, , cf. (9) and (11). Taking the three-dimensional arrays of deformation gradients, , and the first Piola–Kirchhoff stress, , at all integration points and utilizing the MATLAB pageldivide function representing the page-wise left matrix divide, we can compute at all integration points, which is subsequently used to compute the Kronecker delta products from (69). For better visual clarity, these products are not incorporated in the assembly_PP_SiLL function and are treated separately. Using Voigt notation and the symmetry of , the Kronecker delta product (69) for any integration point of is given by the mapping
Eigenvalues, eigenvectors, diagonal functions and projections
Get eigenvalues and eigenvectors from eigenvalue problem .
Determine , and let , (since constant standard metrics used). For compute diagonal functions, derivatives and projections
Coefficients ()
For three different eigenvalues :
For two equal eigenvalues :
and, for all with ,
For three equal eigenvalues :
Nominal tensor operator
Nominal projection tensors
Summarizing the crucial steps, using the output from the constitutive core – current stress , tangent modulus , and from the preprocessing phase – the eigenvalues and eigenvectors of , we proceed with computing the following objects (see Figure 3):
Transformation tensor (4th order) of size and the product term (4th order) of size using (8);
The first Piola–Kirchhoff stress, , in the matrix and 3-D array representations, P and P_3D, of size and , respectively, using (9) and amtam function;
Algebraic objects related to the transformed tangent modulus from (10):
Additional objects required for computing new displacements:
Matrix g of internal forces at each node stored as of size ;
Additional objects required for data analysis and visualization:
Cauchy stress, , of size using (12) and asam, amdet, amamt functions.
Code block 3 provides details on the algorithmization.
% logarithmic stress tensors (3-D array)
Si_3D = reshape([Si(1,:); Si(6,:); Si(5,:); Si(6,:); Si(2,:); Si(4,:); ...
Si(5,:); Si(4,:); Si(3,:)],3,3,n_int); % 3 x 3 x n_int
% assembly of ’PP’ and part of ’Si:LL’ (3-D array)
% 6 x 9 x n_int 9 x 9 x n_int
[PP_3D,SiLLpart_3D] = assembly_PP_SiLL(F_3D,Si_3D,eVal_3D(inds_diag),eVec_3D);
% first Piola-Kirchhoff stress tensors (matrix)
P = amtam(PP_3D,reshape(Si,6,1,n_int)); % 9 x 1 x n_int
P = reshape(P,9,n_int); % 9 x n_int (squeeze)
% first Piola-Kirchhoff stress tensors (3-D array)
P_3D = reshape(P(inds_Voigt,:),3,3,n_int); % 3 x 3 x n_int
% second Piola-Kirchhoff stress tensors (3-D array)
S_3D = pagemldivide(F_3D,P_3D); % 3 x 3 x n_int
% complete contractions ’Si:LL’ including the Kronecker delta products
SiLL_3D = SiLLpart_3D + Kron_delta_product(S_3D); % 9 x 9 x n_int
% consistent tangent moduli (3-D array)
DP_3D = amam(amtam(PP_3D,reshape(DSi,6,6,n_int)),PP_3D) + SiLL_3D; % 9 x 9 x n_int
% weighted tangent moduli (matrix)
DP_w = reshape(DP_3D,81,n_int).*repmat(WEIGHT,81,1); % 81 x n_int
% nodal internal forces (matrix)
g = B’*reshape(repmat(WEIGHT,9,1).*P,9*n_int,1);
g = reshape(g,3,n_n); % 3 x n_n
Code Block 3: Vectorized assemblies in the postprocessing part.
Tangent matrix construction and Newton’s method
The final solution of the mechanical balance embodied in the system (64) is found by semismooth Newton’s method, see Algorithm 1 in [24]. The global vector of internal forces, denoted g in the algorithm, is obtained from the first Piola–Kirchhoff stress, P, and the sparse matrix representing the displacement–gradient operator at all integration points, B. The global tangent stiffness matrix, , crucial for proper convergence of Newton’s method, is obtained as the product of the block-diagonal sparse matrix for the elastoplastic problem, DP_ws, and the displacement–gradient matrix
hence, it is symmetric. Matrix is directly assembled from the constitutive tangents, , at all integration points obtained in the postprocessing phase. In the present implementation, the global tangent stiffness matrix is assembled directly, without the decomposition into a precomputed elastic stiffness matrix and a “plastic correction” introduced in [24]. In the logarithmic strain formulation, the transformed tangent modulus depends on the current deformation even for a purely elastic response, so the correction generally remains nonzero at elastic integration points and the sparsity advantage of this decomposition is lost.
A further consideration is that the modular structure of the implementation allows the constitutive core to be easily substituted by another constitutive model, e.g., the shape memory alloy model presented in our previous work [10], where activation of inelastic processes occurs frequently, i.e., the purely elastic region is rather small. Any potential benefit of separating the elastic contribution would therefore be further limited by the small extent of this region, while requiring modifications of the constitutive core and not recovering the sparsity advantage discussed above.
In order to monitor the convergence of Newton’s method at the -th time step and the -th iteration, we employ the relative increment measured in the energy norm:
Here, is a prescribed threshold used to avoid unnecessary evaluation of the relative increment when the absolute increment is already sufficiently small. The energy norm is defined by
where and denotes the elasticity tensor. This definition follows the approach in [24]. In the finite element implementation, the energy norm is evaluated using the elastic stiffness matrix :
where is the vector of nodal displacement degrees of freedom.
Thanks to the considered independence of from plastic strain (or other state variables), can be precomputed before the main computation procedure starts (cf. the scheme in Figure 2) based on elastic parameters of the material and the displacement-gradient operator, . Newton’s method then iterates until the stopping criterion
is satisfied.
Validation and vectorization performance assessment
In this section, we illustrate improvements in computational efficiency and capabilities to handle geometric nonlinearities when the logarithmic strain approach is used. All computational times together with visualization outputs in this paper were obtained on ThinkPad T14 Gen 4 with AMD Ryzen 7 PRO processor and 32 GB RAM running MATLAB R2024a. The package with codes can be downloaded at [68] or at
https://www.mathworks.com/matlabcentral/fileexchange/185078
Table 3 provides material parameters of the model with their values used for input in computations. Let us note that two common elastic parameters, the bulk modulus, , and the shear modulus, , used as the input to the constitutive model (see § 5.5) are straightforwardly recovered from presumed elastic isotropy. Although the specific values of the parameters were motivated by the behavior of metals and alloys, they do not represent a particular material. We apply a threshold , under which both displacements and are considered equal (see (72)), and as the convergence criterion.
| Symbol | MATLAB variable | Value | Unit | Description |
young | 210 | GPa | Young’s modulus | |
poisson | 0.3125 | – | Poisson’s ratio | |
sqrt(2/3)*Y | 1 | GPa | Yield stress in uniaxial tension | |
a | 1; 10 | GPa | Linear kinematic hardening coefficient |
Table 3. Material parameters used in numerical simulations. The yield stress enters the code through the expression sqrt(2/3)*Y. See text for details.
Vectorization assessment
To demonstrate the computational benefits of vectorization, we consider a simple problem: uniaxial stretching of the unit cube to double its original length in the -direction, corresponding to a maximum prescribed displacement , i.e., 100% nominal strain. We impose homogeneous Dirichlet boundary conditions on the wall , on the wall , and on the wall . On the opposite wall , the displacement component is prescribed uniformly and increased from zero to . All remaining displacement components on the walls are unconstrained.
Depending on the choice of the yield stress in uniaxial tension, , we can switch between purely elastic, i.e., set to a very high number, and fully plastic, i.e., set close to zero, variants in this particular testing problem. In the purely elastic case, no plastic correction of the stress or tangent modulus is required throughout the simulation, whereas in the fully plastic case, both quantities are corrected at every integration point in every time step. Thanks to the character of the problem, the resulting strain and stress fields are homogeneous within the body. In addition, we compare the nonvectorized and vectorized MATLAB implementations. Altogether, we consider four variants of the model: nonvectorized elasticity, nonvectorized plasticity, vectorized elasticity, and vectorized plasticity. For each variant, we perform MATLAB computations on 37 uniformly refined meshes of the unit cube ( elements with ; each element with 8 integration points). Each simulation is divided into 10 equidistant time steps. For a particular type of model, the total number of Newton iterations is independent of mesh refinement and reaches 39 for elasticity and 41 for plasticity. Newton’s method converges in 3–4 iterations per time step, except for the first time step, which requires 5 iterations.5

Figure 4. Computational times for preprocessing and postprocessing phases in the logarithmic strain formulation for uniaxial stretching of a unit cube. Vectorized and nonvectorized implementations are compared on 37 uniformly refined meshes for purely elastic and fully plastic responses of an isotropic material. The panels show: (a) preprocessing, including the evaluation of , , and ; (b) the spectral decomposition of , included in (a); (c) postprocessing, including the evaluation of , , the first Piola–Kirchhoff stress , and the consistent tangent modulus ; and (d) the evaluation of and , included in (c). Times are accumulated over all Newton iterations. See text for details.
Figure 4 contains plots comparing computational time with respect to the number of integration points for all four combinations in different stages of computation. The measured assembly times grow approximately linearly with the number of integration points, indicating nearly optimal scaling. Moreover, as the data points for elasticity and plasticity are very close to each other in all cases, the computational times associated with the assembly operations in the preprocessing and postprocessing parts are largely insensitive to the constitutive response function in this benchmark.
Figure 4(a) compares the total computational time of the preprocessing phase, denoted (A) in Figure 2, where the logarithmic strain tensor is computed at all integration points from the Eq. (7). On the finest mesh, vectorization (see Code block 1) accelerates preprocessing by approximately a factor of 7.5. In the nonvectorized implementation, is calculated by successively applying the MATLAB function eig, which computes the eigenvalues and eigenvectors of a matrix, to the corresponding right Cauchy–Green tensors . The vectorized version operates instead with two 3-D arrays containing the eigenvalues and eigenvectors of at all integration points via the MATLAB function pageeig. Hence, all tensors are computed using spectral decompositions of by directly applying the logarithm to the eigenvalues and reconstructing using the corresponding eigenvectors (common for diagonalizable matrices). This brings a computational speedup by a factor of 10. Figure 4(b) compares computational time savings for the spectral decompositions alone in the preprocessing phase. Other time savings are due to applying functions from own-developed libraries presented in § 5.2 and avoiding related object conversions.
The computational time spent on the postprocessing phase, denoted (C) in Figure 2, is shown in Figure 4(c). Compared to Figure 4(a), postprocessing is generally more time-consuming; the relative time reduction due to vectorization is lower, but the absolute reduction is higher. Figure 4(d) provides computational times related to assemblies of the transformation tensor from (8) and the product from (10) in the first step of the postprocessing phase, which is denoted as (a) within (C) in Figure 2. The nonvectorized version directly adopts the original algorithm of Miehe et al. [1] presented in Figure 3. The vectorized version presented as a function in Code block 4 avoids multiple nested for-loops and performs the operations at all integration points simultaneously. It operates with 3-D arrays of the eigenvalues and eigenvectors of and of other auxiliary variables from Figure 3 and introduces the logical arrays inds1, …, inds5. These determine which relations between the three eigenvalues , , occur at each integration point, see the alternatives listed in step 2. in Figure 3. Evaluation of and the contraction is approximately twice as fast, while complete postprocessing is accelerated by approximately a factor of 2.5. The computational time in Figure 4(c) not covered in Figure 4(d) is spent on determining variables and from (9) and (10), respectively. That part mainly contains basic linear algebra operations, and the speedup there comes from the vectorization functions in Subsection 5.2.
To put these results into the context of the complete Newton iteration procedure, i.e., step (ii) of stage 2. in Figure 2, we present the relative contributions of preprocessing (A), constitutive problem (B), postprocessing (C), global tangent matrix assembly in (D), linear system solution (E), and the remaining operations in Figure 5; contributions are expressed as a percentage of the total Newton time for each corresponding mesh and variant.6 As the mesh is refined, solving the global linearized systems using MATLAB’s backslash operator becomes the principal computational expense. Its relative contribution is larger in the vectorized implementation (93–94% compared to 87–88% on the finest mesh) because vectorization reduces the costs of preprocessing and postprocessing. The substantial speedups of these individual stages translate into a more modest reduction in the whole simulation time. Further substantial acceleration on larger meshes therefore requires improvements to the linear solution stage or modifications of the Newton iterative procedure (cf. [65, 66]), which are beyond the scope of the present work.

Figure 5. Percentage breakdown of the total time spent on Newton iterations for uniaxial stretching of a unit cube (see Subsec. 6.1 and Figure 2). Results are shown for 37 uniformly refined meshes, indexed by , with integration points, considering purely elastic and fully plastic responses of an isotropic material. The panels correspond to: (a) nonvectorized elasticity, (b) nonvectorized plasticity, (c) vectorized elasticity, and (d) vectorized plasticity. Each stacked bar shows the relative contributions of preprocessing, constitutive problem, postprocessing, global tangent matrix assembly, linear system solution, and the remaining operations within Newton’s method. Percentages are calculated relative to the accumulated time of all Newton iterations for the corresponding mesh and case.
The von Mises elastoplastic routine adopted from [24] represents a relatively inexpensive component of the present benchmark. On the finest mesh, constitutive evaluation accounts for approximately 0.2% and 0.6% of the Newton time in the vectorized elastic and plastic calculations, respectively. This finding concerns the particular constitutive model and implementation considered here, which features a vectorized closed-form solution of the constitutive update. Thanks to the modular separation of constitutive evaluation from preprocessing and postprocessing, other constitutive models formulated within the internal variable framework can be incorporated into the same finite strain formulation (e.g., plasticity with damage [6, 8] or shape memory alloys [10]), with additional field equations where required. For more complex models, constitutive evaluation may account for a considerably larger share of the total computation time. Its cost may be reduced through vectorization, parallelization, or tailored numerical approaches, e.g., [69].
Finally, Figure 6 provides the total computation time spent on Newton iterations and on solution of the linear system in our vectorized implementation, both for elastic (a) and plastic (b) models. It confirms that for both constitutive models the linear system provides the most severe computational burden and the absolute linear solution times remain similar between implementations. To quantify the scaling observed in the plots, we approximate the measured times by power laws , where is the number of integration points, over refinement indices . For preprocessing, postprocessing (cf. Figure 4), constitutive evaluation, and global tangent matrix assembly, least-squares fits in logarithmic coordinates yield exponents ranging between 0.93 and 1.04, indicating approximately linear growth of time with problem size. For the accumulated Newton iteration times in elasticity and plasticity, fits yield exponents of 1.76 and 1.79, respectively, and for the corresponding linear-solver the exponents are approximately 1.84 and 1.88; the fitted power laws are plotted by dashed lines in Figure 6.{sup}7 Thus, the linear scaling of pre- and postprocessing confirms the robustness of their vectorization and contributes to the subquadratic growth of the total Newton-iteration time. Let us note for completeness that the remaining processes of the computational workflow, i.e., the first and third stages in {xref}Fig. 2` as well as parts (i) and (iii) of the second one, require negligible computational time () for finer computational meshes (refinement index ).

Figure 6. The accumulated computational time of all Newton iterations, step (ii) of stage 2. in Figure 2, and the total computational time of linear solvers, (E) in Figure 2, for uniaxial stretching of a unit cube together with their power-law fits. Results are shown for vectorized code and 37 uniformly refined meshes with different numbers of integration points, considering purely elastic and fully plastic responses of an isotropic material.
Computational simulations of structural elements
We present simulations of the elastoplastic response of two geometric domains, an Ω-shaped and a coil-shaped, which are motivated by structural elements in applications. The examples are chosen to demonstrate the overall performance of the implementation and, at the same time, the ability of the vectorized version of Miehe’s approach to handle large rotations and large strains in computational analysis. In visualizations, we use the engineering scalars called von Mises stress and equivalent plastic strain{sup}8`, which are defined as
Let us note that in the logarithmic strain approach, the yield condition is imposed on the relative logarithmic stress (cf. [7]), i.e., on in our case. Hence, the Cauchy von Mises stress (obtained by transformation from ) cannot be used as a direct indicator of plastic activities. However, it can provide a fast clue for assessing the situation in monotonic loading paths starting in an unplasticized state.

Figure 8. -shaped domain from Benchmark 6.2.1: the initial configuration (grey mesh) and the final deformation with the underlying von Mises stress (in MPa).

Figure 9. -shaped domain from Benchmark 6.2.1: the initial configuration (grey mesh) and the final deformation, with elements where plasticity has been activated marked in yellow and elastically loaded ones marked in blue.
Benchmark 1: -shaped domain
We consider a three-dimensional -shaped domain; see Figure 7(a), which can be considered as a building element of a long, recurring pattern in the -direction. Its projection onto the -plane together with the specification of dimensions is depicted in Figure 7(b). The width in the -direction is set to 0.5 mm. The outer left and right faces, whose nodes are marked by green and red points in the figure ( mm and mm, respectively), are moved apart. This is prescribed by nonhomogeneous Dirichlet boundary conditions in the -direction with maximum displacements of and on the left and right sides, respectively, where mm. Additionally, the central nodes of both faces are fixed in the - and -directions. To prevent rigid-body motion, the central node of the middle (symmetry) plane, , is also fixed in the -direction. The computational mesh consists of 64,512 hexahedral elements (4 cross-sectional layers with 16,128 elements each) and 516,096 corresponding (Gauss) integration points. For visual clarity, a coarser mesh with only 2016 elements (corresponding to of the number of elements in the computational mesh) is superimposed in Figure 7. The entire simulation consists of 240 uniform time steps with material parameters given in Table 3, GPa.

Figure 7. Ω-shaped domain from the first benchmark: its 3D view (a) and a 2D projection in -plane (b). A coarse computational mesh is used only for illustrative purposes; see text for details.

Figure 10. Ω-shaped domain from Benchmark 6.2.1: the initial configuration (grey mesh) and the final deformation with the underlying equivalent plastic strain.
Figs. 8, 9, and 10 show the deformed configuration at the final time step, along with the initial mesh configuration in grey. Thanks to the geometry and boundary conditions, the results do not vary with the thickness (-direction) of the Ω-shaped element. In Fig. 8, the deformed configuration is overlaid with the distribution of von Mises stress. The most loaded parts are the arcs situated at the bottom and top of the structure, with equivalent stress reaching more than 2.5 GPa on the surfaces. From the mechanics perspective, the inner surfaces of the arcs are in tension, whereas the outer surfaces are compressed. The plotted Cauchy von Mises stress visualizes the intensity of the current stress state. It is not itself the decisive factor for the plastic flow – the scalar function plays this role for the present model. However, for monotonic loading starting with no plastic strain, the comparison of von Mises stress with the yield stress provides a clue for identification of critical regions of the material. Fig. 9 shows elements with nonzero current equivalent plastic strain, , in yellow, and the remaining elements in blue; this identifies regions with plastic-strain history. Finally, as documented in Fig. 10, where the distribution of equivalent plastic strain is shown, the intensity of plastification varies significantly. The equivalent plastic strain grows rapidly near the four arcs, reaching maxima of about 0.19 on the stretched inner surfaces. Such detailed information on the presence and intensity of the plastic process may be useful in designing real applications for optimizing their functionality and lifespan.
Benchmark 2: a coil
In this benchmark, we consider a three-dimensional coil (ring) with a circular cross-section. The coil cross-section radius is 5 mm, the outer radius is 10 cm, and its height, i.e., the vertical distance between the central nodes of the two end cross-sections, is 2 cm. The computational domain is depicted in Figure 11 on the left. All nodes of the bottom end cross-section are fixed in all three spatial directions. The coil is loaded by prescribing displacement of the central node of the upper cross-section (marked in red) in the vertical -direction, while its - and -displacements remain fixed. The coil is stretched up to cm, then the stretch is released until the -component of the force at the central node of the upper cross-section vanishes, which occurs at cm. The computational mesh consists of
Figure 11. Coil domain from Benchmark 6.2.2 (left) and its circular cross-section (right) with the geometry of the FE mesh in black.
36,480 hexahedral elements, arranged in 160 layers along the main axis with 228 elements per layer (a coarser mesh is depicted in the left part of Figure 11). The entire simulation comprises 240 uniform time steps (200 for loading, 40 for unloading). We consider material parameters from Table 3; the kinematic hardening coefficient is now decreased to GPa.
Figure 12 shows four snapshots from the computation corresponding to the displacement of the elevated node ( of 13.2 cm, 26.6 cm, 40.0 cm for loading and 32.1 cm for unloading, where the force in the vertical direction reaches zero; see Table 4 for an overview and Figure 13 for the evolution of the vertical component of force with stroke at the elevated node. In each snapshot, the initial configuration and the most stretched configuration are plotted as the meshed surface in grey, whereas the actual configuration is overlaid with the distribution of von Mises stress.
| Snapshot | [cm] | [1] |
| 13.2 | ||
| 26.6 | ||
| 40.0 | 1 | |
| 32.1 |
Table 4. Displacement values of the moved node of the deformed coil for the four snapshots discussed in the text.

Figure 12. Benchmark 6.2.2: von Mises stress (in MPa) at different stages of stretching –. See text for details.

Figure 13. Benchmark 6.2.2: the force-stroke relation with four particular stages of stretching – marked by red points. See text for details.
Although the macroscopic force response up to in Figure 13 appears slightly nonlinear, the corresponding snapshot in Figure 12 shows substantial heterogeneity along the coil’s central fiber, with very low stress near the moved end and higher stress below. A similar situation occurs during further loading (snapshots –): the moved end of the coil exhibits low von Mises stress; the surface of the central part is loaded close to 1000 MPa, whereas the stress in the fixed end of the coil increases from values below 700 MPa for to values reaching the maximum of the whole simulation, over 1100 MPa, for . This shows a highly inhomogeneous stress state along the coil’s central fiber, driven by the imposed boundary conditions; moreover, the large rotation of mesh elements farther from the fixed end is clearly visible. After unloading (snapshot ), the stress on the surface drops everywhere, but it now appears distributed inhomogeneously also on the outer edges of the coil cross-sections.
The last finding is further illustrated in Figure 14, where the distribution of von Mises stress within five cross-sections of the coil is presented for snapshots – from Figure 12. The five cross-sections were chosen at different relative positions along the central fiber of the coil. Defining the relative position of the fixed end and the moved end as 0 and 1, respectively, the cross-sections at relative positions 0 (=bottom), 1/4, 1/2 (=middle), 3/4 and 1 (=top) are shown. The plots confirm that the inhomogeneous stress distribution also occurs within the cross-section, caused by the combination of torsional and bending strain in this helical-spring-derived geometry (cf. [70, 71, 72]). During stretching, the dominant straining mode shifts from torsion to bending; e.g., see [72]. Hence, the circular symmetry of the stress distribution is broken, and mirror symmetry imposed by bending appears. This is clearly seen for the cross-section denoted 3/4 and for the stress distribution at . After unloading, the stress distribution is heavily influenced by the permanent plastic strain generated during stretching; see also Appendix § 12.§ 4. Let us note that the inhomogeneous residual stresses can be investigated in more detail using dedicated FEM techniques [73, 74].

Figure 14. Benchmark 6.2.2: von Mises stress (in MPa) on particular cross-sections (bottom, 1/4, middle, 3/4, and top with respect to the central fiber) for stages of stretching . See text for details.
Conclusions
More than two decades after the seminal work [1], the logarithmic strain framework has become a popular choice for upgrading engineering small-strain material models toward large deformations. The intrinsic multiplicative nature of finite-strain decomposition is mapped by a logarithmic function onto the additive structure of geometrically linear theory, allowing seamless integration of additive constitutive models without modification and shifting the effort to constitutive-core-independent, purely geometric pre- and post-processing phases. We have studied this shift both from the theoretical mathematical and practical computational perspectives, taking von Mises elastoplasticity with linear kinematic hardening as a clear and well-known prototype.
In the mathematical analysis, we have established the existence of energetic solutions for the gradient-regularized quasistatic model, under the assumptions of Theorem A.1. The key challenge was addressing the elastic energy inheriting the additive nature from the small-strain ancestor; since this is typical for this class of models, the applied approach can serve as a methodological template for other class instances. In the computational part, we focused on the effective algorithmic treatment of tensor transformations in the pre- and post-processing phases, which are independent of the constitutive core and therefore vital for any practical implementation. We exploited the capabilities of the advanced vectorization tools and our own developed techniques in MATLAB code [27, 75, 34] and significantly accelerated the pre- and post-processing phases so that, for medium-sized FEM problems, the decisive computational limit is imposed by the solution of the linear system within the Newton method and potentially the constitutive update routine in case of more complex constitutive laws, not these vectorized phases. Let us note for completeness that we built on the implementation with optimized tangent matrix assembly [24]. In a broader context, this work also illustrates the versatility of our vectorization techniques: here they are applied to a geometrically nonlinear problem whose linearizations need not be elliptic, which extends the range of problems treated in our previous works [27, 24, 75].
The benchmark simulations demonstrated the applicability of the FEM implementation to resolving the mechanical response of geometries undergoing large displacements and rotations. They also illustrated that detailed information on physical quantities, e.g., stresses and internal variable(s) (plastic strains), can be provided. Let us note that advanced characterization techniques can provide experimental counterparts to such a type of data (e.g., [72, 76, 77, 78]), opening the possibilities of experimental validation of model predictions.
The separation of geometric transformations from constitutive evaluation facilitates extensions to other material models compatible with the logarithmic strain framework. Such extensions require appropriate constitutive equations and internal-variable updates, while the geometric preprocessing and postprocessing can be retained when the strain measure and stress conjugacy remain unchanged. Models involving additional fields and/or spatial gradients require corresponding extensions of the global formulation [7, 8].
Declaration of competing interest
The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.
Data availability
Data are available at [79]. The software is available at [68].
Acknowledgements
This work has been financially supported by the Czech Science Foundation [Project No. 24-10366S] and by the Operational Programme Johannes Amos Comenius of the Ministry of Education, Youth and Sport of the Czech Republic, within the frame of project Ferroic Multifunctionalities (FerrMion) [Project No. CZ.02.01.01/00/22_008/0004591], co-funded by the European Union.
CRediT authorship contribution statement
M Frost: Conceptualization, Methodology, Validation, Writing – Original Draft, Supervision. M Kružík: Conceptualization, Methodology, Validation, Writing – Original Draft. A Moskovka: Software, Validation, Data curation, Writing - Original draft preparation, Visualization. J Valdman: Methodology, Software, Writing – Review & Editing.
Appendix
Small-strain constitutive model of von Mises elastoplasticity with linear kinematic hardening
Let us recall the constitutive model representing von Mises elastoplasticity with linear kinematic hardening in small strains. The state of the material is defined by the total strain (observable) and the plastic strain (internal variable):
The free energy, , is decomposed into an elastic part, , and a stored energy part due to the linear kinematic hardening, :
where is the fourth-order elastic stiffness tensor and is the kinematic hardening modulus. The thermodynamic forces are derived from the partial derivatives of the free energy:
Here, is the Cauchy stress, is the backstress, and is the relative stress (the force driving dissipation). The dissipation (pseudo)potential takes the form
with denoting the yield stress for uniaxial loading. Now, the solution of the constitutive problem (state update) can be formally written as a solution of an extremal problem [50]
Although this is a less conventional formulation, it is fully equivalent to the “classical” alternative, e.g., [44], written as follows. First, the elastic domain is defined by the von Mises yield criterion:
The evolution of the internal variable follows the normality rule
which results in the associative flow rule:
subject to the Karush-Kuhn-Tucker conditions:
Existence of energetic solutions
We formulate the theorem on the existence of energetic solutions for the elastoplastic model introduced in § 3 and briefly sketch its proof. We refer the reader to the classical works [13, 14, 15] for further details of the technique.
Theorem A.1. Let be bounded with a sufficiently regular boundary and let have positive surface measure. Assume
and let . For the quadratic elastic energy with linear kinematic hardening used in the applications, the growth assumption below is satisfied with .
Assume that
and that there are constants such that
and
Assume that
is convex, lower semicontinuous, and coercive in the sense that
Assume that is convex, positively one-homogeneous, and satisfies
Let
be such that each is an orientation-preserving diffeomorphism and
uniformly in . Assume further that
Let the initial state
have finite energy and satisfy the initial global stability condition
for all admissible competitors . Then there exists an energetic solution
such that
and, for every ,
Moreover,
and the physical deformation
satisfies
The energetic solution satisfies the global stability condition and the energy balance stated above.
Brief sketch of the proof. A central estimate used in the proof is
with a constant independent of . Consequently,
for some .
To justify the direct-method step, one first uses bounded energy to obtain a uniform bound on the deformation and a bound on the plastic variable. The embedding into , together with the inverse-determinant penalty, gives a uniform positive lower bound for the determinant on energy sublevels. Thus, the logarithmic strain is continuous along the strongly convergent deformation gradients. Compactness of the plastic variable then yields convergence of the elastic-energy term; convexity and weak lower semicontinuity of the gradient penalties and the dissipation handle the remaining terms.
The proof is based on the incremental problems
followed by the direct method, uniform energy estimates, a -variation estimate for , Helly’s selection principle, and passage to the limit in the discrete stability and energy inequalities.
The essential compactness mechanism is
Together with
the inverse-determinant term yields a positive lower bound for on bounded energy sublevels. Hence, the logarithmic strain is continuous along minimizing sequences. In particular, let us stress that no quasiconvexity or polyconvexity of
is required for the regularized problem.
While the regularizing terms in (34) are necessary for the current analysis, the simulations in § 6 are performed for the non-regularized model, i.e., formally for and , which is the formulation commonly accepted and used in computational practice [24, 44]. Let us comment on the relation between the two settings from a theoretical point of view.
Time discretization. Energetic solutions are obtained as limits of solutions of the time-incremental minimization problems,
i.e., from the incremental energy minimization principle, cf. (25) and the discussion therein. For , and up to the reformulation of the Dirichlet data through , the optimality conditions of these incremental problems are the time-discrete equilibrium equations (42) with vanishing volume and surface forces, together with the local return mapping at the quadrature points. Hence, the algorithm of § 5 computes stationary points of the same incremental functionals without the regularizing terms; since Newton’s method is a local method, these stationary points need not be global minimizers.
Spatial discretization. On a fixed finite element mesh, the incremental problems are finite-dimensional. At fixed mesh size, existence of an incremental minimizer can be established under appropriate discrete coercivity assumptions (including a quadrature rule that controls the discrete deformation gradients), provided the admissible set is nonempty, and orientation preservation is enforced at the quadrature points. The logarithmic-strain energy has a singularity as an eigenvalue of approaches zero, and its growth in the other singular values controls large discrete gradients. The precise discrete coercivity also depends on the boundary constraints and the hardening term; these conditions should not be inferred from continuity of the energy alone. The corresponding bounds are, however, not uniform with respect to the mesh size , and without regularization one cannot expect compactness of the discrete solutions as . This is where the regularizing terms become indispensable.
The limit . For a fixed deformation with integrable second gradient and Jacobian bounded away from zero, the regularizing terms contribute only to the energy, so the regularized and the non-regularized incremental functionals are close on such configurations. The behaviour of the energetic solutions as is, however, not covered by our analysis. Since the elastic energy is not quasiconvex, minimizing sequences of the limit problem may develop fine-scale oscillations, and the limit is expected to involve a relaxed energy. This is consistent with the loss of ellipticity of the logarithmic-strain model reported in [47] at excessive strains. A rigorous analysis of the joint limit , is left for future work.
Vectorized assembly of transformation operators in the postprocessing phase
We provide a code block with details on the vectorized implementation of part (Ca) of the postprocessing phase in Figure 2.
function [PP, SiLL_part] = assembly_PP_SiLL(F, stress, Eigs, EigVecs)
tol = 1e−10; % tolerance under which we can consider two eigenvalues to be the same
% 1 6 5
% 9 2 4 (Voigt notation)
% 8 7 3
N = size(F,3); % number of integration points
n = amam(F,EigVecs); % 3x3xN (non-symmetric)
d = 1./Eigs; % 3xN
epsi = log(Eigs)/2; % 3xN
dzeta = amam(amtam(EigVecs,stress),EigVecs); % 3x3xN (symmetric)
Eigs12 = Eigs(1,:) − Eigs(2,:); % 1xN
Eigs13 = Eigs(1,:) − Eigs(3,:); % 1xN
Eigs23 = Eigs(2,:) − Eigs(3,:); % 1xN
d1 = d(1,:); d2 = d(2,:); d3 = d(3,:); % 1xN
epsi1 = epsi(1,:); epsi2 = epsi(2,:); epsi3 = epsi(3,:); % 1xN
inds1 = abs(Eigs12)>tol & abs(Eigs23)>tol & abs(Eigs13)>tol; % (1) all eigenvalues are different
inds2 = abs(Eigs12)>tol & abs(Eigs23)>tol & abs(Eigs13)<tol; % (2) l1 == l3, l2 is different
inds3 = abs(Eigs12)>tol & abs(Eigs23)<tol; % (3) l2 == l3, l1 is different
inds4 = abs(Eigs12)<tol & abs(Eigs13)>tol; % (4) l1 == l2, l3 is different
inds5 = abs(Eigs12)<tol & abs(Eigs13)<tol; % (5) l1 == l2 == l3
theta12 = zeros(1,N); theta13 = zeros(1,N); theta23 = zeros(1,N); % 1xN
if any(inds1)
theta12(inds1) = (epsi1(inds1) − epsi2(inds1))./Eigs12(inds1);
theta13(inds1) = (epsi1(inds1) − epsi3(inds1))./Eigs13(inds1);
theta23(inds1) = (epsi2(inds1) − epsi3(inds1))./Eigs23(inds1);
end
if any(inds2)
% never occurs as the eigenvalues are always sorted
end
if any(inds3)
theta12(inds3) = (epsi1(inds3) − epsi2(inds3))./Eigs12(inds3);
theta13(inds3) = (epsi1(inds3) − epsi3(inds3))./Eigs13(inds3);
theta23(inds3) = 0.5*d2(inds3);
end
if any(inds4)
theta12(inds4) = 0.5*d1(inds4);
theta13(inds4) = (epsi1(inds4) − epsi3(inds4))./Eigs13(inds4);
theta23(inds4) = (epsi2(inds4) − epsi3(inds4))./Eigs23(inds4);
end
if any(inds5)
theta12(inds5) = 0.5*d1(inds5);
theta13(inds5) = theta12(inds5);
theta23(inds5) = theta12(inds5);
end
scalA = @(x) reshape(x,1,[]);
EV11 = scalA(EigVecs(1,1,:)); EV12 = scalA(EigVecs(1,2,:)); EV13 = scalA(EigVecs(1,3,:)); % 1xN
EV21 = scalA(EigVecs(2,1,:)); EV22 = scalA(EigVecs(2,2,:)); EV23 = scalA(EigVecs(2,3,:)); % 1xN
EV31 = scalA(EigVecs(3,1,:)); EV32 = scalA(EigVecs(3,2,:)); EV33 = scalA(EigVecs(3,3,:)); % 1xN
n11 = scalA(n(1,1,:)); n12 = scalA(n(1,2,:)); n13 = scalA(n(1,3,:)); % 1xN
n21 = scalA(n(2,1,:)); n22 = scalA(n(2,2,:)); n23 = scalA(n(2,3,:)); % 1xN
n31 = scalA(n(3,1,:)); n32 = scalA(n(3,2,:)); n33 = scalA(n(3,3,:)); % 1xN
M1 = reshape(2*[n11.*EV11; n21.*EV21; n31.*EV31; n21.*EV31; n11.*EV31; n11.*EV21; ...
n31.*EV21; n31.*EV11; n21.*EV11],1,9,N); % 1x9xN
M2 = reshape(2*[n12.*EV12; n22.*EV22; n32.*EV32; n22.*EV32; n12.*EV32; n12.*EV22; ...
n32.*EV22; n32.*EV12; n22.*EV12],1,9,N); % 1x9xN
M3 = reshape(2*[n13.*EV13; n23.*EV23; n33.*EV33; n23.*EV33; n13.*EV33; n13.*EV23; ...
n33.*EV23; n33.*EV13; n23.*EV13],1,9,N); % 1x9xN
M4 = reshape([n12.*EV13+n13.*EV12; n22.*EV23+n23.*EV22; n32.*EV33+n33.*EV32; ...
n22.*EV33+n23.*EV32; n12.*EV33+n13.*EV32; n12.*EV23+n13.*EV22; ...
n32.*EV23+n33.*EV22; n32.*EV13+n33.*EV12; n22.*EV13+n23.*EV12],1,9,N); % 1x9xN
M5 = reshape([n11.*EV13+n13.*EV11; n21.*EV23+n23.*EV21; n31.*EV33+n33.*EV31; ...
n21.*EV33+n23.*EV31; n11.*EV33+n13.*EV31; n11.*EV23+n13.*EV21; ...
n31.*EV23+n33.*EV21; n31.*EV13+n33.*EV11; n21.*EV13+n23.*EV11],1,9,N); % 1x9xN
M6 = reshape([n11.*EV12+n12.*EV11; n21.*EV22+n22.*EV21; n31.*EV32+n32.*EV31; ...
n21.*EV32+n22.*EV31; n11.*EV32+n12.*EV31; n11.*EV22+n12.*EV21; ...
n31.*EV22+n32.*EV21; n31.*EV12+n32.*EV11; n21.*EV12+n22.*EV11],1,9,N); % 1x9xN
%=======================
% Assembly of PP matrix
%=======================
PP11 = 0.5 * asam(d1,amam(reshape([EV11.*EV11; EV21.*EV21; EV31.*EV31; ...
2*EV21.*EV31; 2*EV11.*EV31; 2*EV11.*EV21],6,1,N),M1)); % 6x9xN
PP22 = 0.5 * asam(d2,amam(reshape([EV12.*EV12; EV22.*EV22; EV32.*EV32; ...
2*EV22.*EV32; 2*EV12.*EV32; 2*EV12.*EV22],6,1,N),M2)); % 6x9xN
PP33 = 0.5 * asam(d3,amam(reshape([EV13.*EV13; EV23.*EV23; EV33.*EV33; ...
2*EV23.*EV33; 2*EV13.*EV33; 2*EV13.*EV23],6,1,N),M3)); % 6x9xN
PP12 = 2 * asam(theta12, amam(reshape([EV11.*EV12; EV21.*EV22; EV31.*EV32; ...
EV21.*EV32 + EV22.*EV31; EV11.*EV32 + EV12.*EV31; EV11.*EV22 + EV12.*EV21],6,1,N),M6)); % 6x9xN
PP13 = 2 * asam(theta13, amam(reshape([EV11.*EV13; EV21.*EV23; EV31.*EV33; ...
EV21.*EV33 + EV23.*EV31; EV11.*EV33 + EV13.*EV31; EV11.*EV23 + EV13.*EV21],6,1,N),M5)); % 6x9xN
PP23 = 2 * asam(theta23, amam(reshape([EV12.*EV13; EV22.*EV23; EV32.*EV33; ...
EV22.*EV33 + EV23.*EV32; EV12.*EV33 + EV13.*EV32; EV12.*EV23 + EV13.*EV22],6,1,N),M4)); % 6x9xN
PP = PP11 + PP12 + PP13 + PP22 + PP23 + PP33; % 6x9xN
%==========================
% Assembly of Si:LL matrix
%==========================
if nargout==2
f = -2./Eigs.^2; % 3xN
f1 = f(1,:); f2 = f(2,:); f3 = f(3,:); % 1xN
ksi12 = zeros(1,N); ksi13 = zeros(1,N); ksi23 = zeros(1,N); % 1xN
ksi21 = zeros(1,N); ksi31 = zeros(1,N); ksi32 = zeros(1,N); % 1xN
eta = zeros(1,N); % 1xN
if any(inds1)
ksi12(inds1) = +(theta12(inds1) - 0.5*d2(inds1))./Eigs12(inds1); ...
ksi21(inds1) = -(theta12(inds1) - 0.5*d1(inds1))./Eigs12(inds1); ...
ksi13(inds1) = +(theta13(inds1) - 0.5*d3(inds1))./Eigs13(inds1); ...
ksi31(inds1) = -(theta13(inds1) - 0.5*d1(inds1))./Eigs13(inds1); ...
ksi23(inds1) = +(theta23(inds1) - 0.5*d3(inds1))./Eigs23(inds1); ...
ksi32(inds1) = -(theta23(inds1) - 0.5*d2(inds1))./Eigs23(inds1); ...
eta(inds1) = eps1(inds1)./Eigs12(inds1)./Eigs13(inds1) - ...
eps2(inds1)./Eigs12(inds1)./Eigs23(inds1) + ...
eps3(inds1)./Eigs13(inds1)./Eigs23(inds1);
end
if any(inds2)
1;
end
if any(inds3)
ksi12(inds3) = +(theta12(inds3) - 0.5*d2(inds3))./Eigs12(inds3); ...
ksi21(inds3) = -(theta12(inds3) - 0.5*d1(inds3))./Eigs12(inds3); ...
ksi13(inds3) = +(theta13(inds3) - 0.5*d3(inds3))./Eigs13(inds3); ...
ksi31(inds3) = -(theta13(inds3) - 0.5*d1(inds3))./Eigs13(inds3); ...
``
ksi23(inds3) = 0.125*f2(inds3); ksi32(inds3) = ksi23(inds3);
eta(inds3) = ksi12(inds3); % equal to ’ksi13’
end
if any(inds4)
ksi12(inds4) = 0.125*f1(inds4); ksi21(inds4) = ksi12(inds4); ...
ksi13(inds4) = +(theta13(inds4) − 0.5*d3(inds4))./Eigs13(inds4); ...
ksi31(inds4) = −(theta13(inds4) − 0.5*d1(inds4))./Eigs13(inds4); ...
ksi23(inds4) = +(theta23(inds4) − 0.5*d3(inds4))./Eigs23(inds4); ...
ksi32(inds4) = −(theta23(inds4) − 0.5*d2(inds4))./Eigs23(inds4); ...
eta(inds4) = ksi31(inds4); % equal to ’ksi32’
end
if any(inds5)
ksi12(inds5) = 0.125*f1(inds5); ksi21(inds5) = ksi12(inds5); ...
ksi13(inds5) = ksi12(inds5); ksi31(inds5) = ksi12(inds5); ...
ksi23(inds5) = ksi12(inds5); ksi32(inds5) = ksi12(inds5); ...
eta(inds5) = 0.125*f1(inds5);
end
dzeta11 = scalA(dzeta(1,1,:)); dzeta22 = scalA(dzeta(2,2,:)); dzeta33 = scalA(dzeta(3,3,:)); % 1xN
dzeta12 = scalA(dzeta(1,2,:)); dzeta13 = scalA(dzeta(1,3,:)); dzeta23 = scalA(dzeta(2,3,:)); % 1xN
scalB = @(x) reshape(x,1,1,[]);
%% --- SiLL123 --------------------------------------------------------------
w1 = scalB(f1 .* dzeta11);
w2 = scalB(f2 .* dzeta22);
w3 = scalB(f3 .* dzeta33);
%% --- SiLL4 -----------------------------------------------------------------
A4 = ...
M4 .* scalB(ksi23 .* dzeta33 + ksi32 .* dzeta22) + ...
2 * scalB(dzeta23) .* (scalB(ksi23).*M3 + scalB(ksi32).*M2) + ...
2 * scalB(eta.*dzeta13) .* M6; % 1x9xN
%% --- SiLL5 -----------------------------------------------------------------
A5 = ...
M5 .* scalB(ksi13.*dzeta33 + ksi31.*dzeta11) + ...
2 * scalB(dzeta13) .* (scalB(ksi13).*M3 + scalB(ksi31).*M1) + ...
2 * scalB(eta.*dzeta12) .* M4; % 1x9xN
%% --- SiLL6 -----------------------------------------------------------------
A6 = ...
M6 .* scalB(ksi12.*dzeta22 + ksi21.*dzeta11) + ...
2 * scalB(dzeta12) .* (scalB(ksi12).*M2 + scalB(ksi21).*M1) + ...
2 * scalB(eta.*dzeta23) .* M5; % 1x9xN
%%
SiLL = 0.125*(amtam(M1.*w1,M1) + amtam(M2.*w2,M2) + amtam(M3.*w3,M3)) + ...
amtam(A4, M4) + amtam(A5, M5) + amtam(A6, M6);
SiLL_part = SiLL + amt(SiLL); % 9x9xN
end
end
Code Block 4: Vectorized assembly of the transformation tensor and contraction from (8) and (10).
Distribution of von Mises plastic strain within cross-section of the coil from Benchmark 6.2.2
Fig. 15 provides the distribution of equivalent plastic strain through particular coil cross-sections for stages of stretching , see Table 4. The positions of cross-sections correspond to the relative distances 0 (=bottom), 1/4, 1/2 (=middle), 3/4, and 1 (=top) along the central fiber of the coil starting from the fixed end.
The plots confirm that up to stretching , most of the material responds elastically; just the surface of the middle cross-section starts to plastify. Consistent with the increase in von Mises stress in Figure 14, the bottom cross-section shows the most pronounced increase in plasticity at . At stretch , the plastification becomes even more pronounced; the maximum equivalent plastic strain reaches . Yet, the radial symmetry is preserved because of the dominant torsional loading, cf. Figure 14. However, such a symmetry is broken, e.g., for the middle cross-section, where the torsion is combined with bending. No plastic deformation has been initiated within the top cross-section. During unloading to , the distribution of plastic strain is unaltered, which corresponds to purely elastic unloading.

Figure 15. Benchmark 6.2.2: equivalent plastic strain on particular coil cross-sections for stages of stretching . See text for details.
References
- [1]C. Miehe, N. Apel, M. Lambrecht, Anisotropic additive plasticity in the logarithmic strain space: modular kinematic formulation and implementation based on incremental minimization principles for standard materials, Computer Methods in Applied Mechanics and Engineering 191 (2002) 5383–5425.DOI
- [2]C. Miehe, J. Ménédiez, S. Gökpete, L.-M. Schänzel, Coupled thermoviscoplasticity of glassy polymers in the logarithmic strain space based on the free volume theory, International Journal of Solids and Structures 48 (2011) 1799–1816.
- [3]K. Anguige, P. Dondl, M. Kružíк, On the existence of minimisers for strain-gradient single-crystal plasticity, ZAMM-Journal of Applied Mathematics and Mechanics/Zeitschrift für Angewandte Mathematik und Mechanik 98 (2018) 431–447.arxiv.org/abs/1701.01033
- [4]M. Kružík, J. Zeman, Elastoplasticity of gradient-polyconvex materials, Zeitschrift für angewandte Mathematik und Physik 72 (2021) 174.DOI
- [5]C. Miehe, F. Welcheninger, F. Aldakheel, Variational gradient plasticity at finite strains. Part II: Local–global updates and mixed finite elements for additive plasticity in the logarithmic strain space, Comput. Methods Appl. Mech. Eng. 268 (2014) 704–734.DOI
- [6]M. Horák, M. Jirásek, An extension of small-strain models to the large-strain range based on an additive decomposition of a logarithmic strain, in: J. Chleboun, K. Segeth, J. Šístek, T. Vejchodský (Eds.), Programs and Algorithms of Numerical Mathematics. Proceedings of Seminar., Institute of Mathematics AS CR, Prague, 2013, pp. 88–93.
- [7]H. Holthusen, T. Brepols, S. Reese, J.-W. Simon, A two-surface gradient-extended anisotropic damage model using a second-order damage tensor coupled to additive plasticity in the logarithmic strain space, J. Mech. Phys. Solids 163 (2022) 104833.DOI
- [8]J. Friedlein, J. Mergheim, P. Steinmann, Efficient gradient enhancements for plasticity with ductile damage in the logarithmic strain space, European Journal of Mechanics - A/Solids 99 (2023) 104946.DOI
- [9]S. Chattopadhyay, L. A. Woodworth, M. Kaliske, Finite strain modelling of shape memory alloys in the logarithmic strain space: a comparative study with other finite strain approaches, International Journal of Solids and Structures 299 (2024) 112892.DOI
- [10]A. Moskovka, M. Horák, J. Valdman, M. Knapek, M. Janeček, P. Sedlák, M. Frost, Finite-strain constitutive model for shape memory alloys formulated in the logarithmic strain space, Shape Memory and Superelasticity 11 (2025) 726–737.DOI
- [11]A. H. Al-Mohy, N. J. Higham, Improved inverse scaling and squaring algorithms for the matrix logarithm, SIAM Journal on Scientific Computing 34 (2012) C153–C169.DOI
- [12]A. H. Al-Mohy, N. J. Higham, S. D. Relton, Computing the Fréchet derivative of the matrix logarithm and estimating the condition number, SIAM Journal on Scientific Computing 35 (2013) C394–C410.DOI
- [13]M. Ortiz, E. A. Repetto, Nonconvex energy minimization and dislocation structures in ductile single crystals, J. Mech. Phys. Solids 47 (1999) 397–462.DOI
- [14]A. Mielke, Energetic formulation of multiplicative elasto-plasticity using dissipation distances, Cont. Mech. Thermodyn 15 (2003) 351–382.DOI
- [15]J. M. Ball, J. C. Currie, P. L. Olver, Null Lagrangians, weak continuity, and variational problems of arbitrary order, J. Funct. Anal. 41 (1981) 135–174.
- [16]R. A. Toupin, Elastic materials with couple-stresses, Arch. Ration. Mech. Anal. 11 (1962) 385–414.DOI
- [17]A. E. Green, R. S. Rivlin, Multipolar continuum mechanics, Arch. Ration. Mech. Anal. 17 (1964) 113–147.
- [18]S. Forest, Micromorphic approach for gradient elasticity, viscoplasticity, and damage, J. Eng. Mech. 135 (2009) 117–131.DOI
- [19]A. Mielke, T. Roubíček, Rate-independent elastoplasticity at finite strains and its numerical approximation, Math. Models Methods in Appl. Sci. 26 (2016) 2203–2236.
- [20]S. Forest, K. Sab, Finite-deformation second-order micromorphic theory and its relations to strain and stress gradient models, Math. Mech. Solids 25 (2020) 1429–1449.
- [21]J. Koko, Vectorized MATLAB codes for linear two-dimensional elasticity, Scientific Programming 15 (2007) 157–172.DOI
- [22]J. Koko, Fast MATLAB assembly of FEM matrices in 2D and 3D using cell-array approach, International Journal of Modeling, Simulation, and Scientific Computing 7 (2016) 1650010.DOI
- [23]T. Weinberg, Fast implementation of mixed RTO finite elements in MATLAB, SIAM Undergraduate Research Online 12 (2019) 246–256.
- [24]M. Čermák, S. Sysala, J. Valdman, Efficient and flexible MATLAB implementation of 2D and 3D elastoplastic problems, Applied Mathematics and Computation 355 (2019) 595–614.arxiv.org/abs/1805.04155
- [25]G. K. Rose, Computational Methods for Nonlinear Systems Analysis With Applications in Mathematics and Engineering, Ph.D. thesis, Old Dominion University, 2017.DOI
- [26]S. A. Funken, D. Praetorius, P. Wissgott, Efficient implementation of adaptive P1-FEM in MATLAB, Computational Methods in Applied Mathematics 11 (2011) 460–490.DOI
- [27]T. Rahman, J. Valdman, Fast MATLAB assembly of FEM matrices in 2D and 3D: nodal elements, Applied Mathematics and Computation 219 (2013) 7151–7158.
- [28]I. Anjam, J. Valdman, Fast MATLAB assembly of FEM matrices in 2D and 3D: edge elements, Applied Mathematics and Computation 267 (2015) 252–263.DOI
- [29]H. N. Mallesham, K. Porwal, J. Valdman, S. K. Acharya, Vectorized implementation of primal hybrid FEM in MATLAB, Computers & Mathematics with Applications 180 (2025) 144–165.
- [30]H. N. Mallesham, G. Sharat, J. Valdman, S. K. Acharya, Vectorized 3D mesh refinement and implementation of primal hybrid FEM in MATLAB, Computational Methods in Applied Mathematics 26 (2026) 419–439.arxiv.org/abs/2509.11133
- [31]M. Inn erberger, D. Praetorius, MoAFEM: An object oriented MATLAB code for higher-order adaptive FEM for (nonlinear) elliptic PDEs, Applied Mathematics and Computation 442 (2023) 127731.DOI
- [32]F. Cuvelier, C. Japhet, G. Scarella, An efficient way to assemble finite element matrices in vector languages, BIT Numerical Mathematics 56 (2016) 833–864.arxiv.org/abs/1401.3301
- [33]A. Mielke, T. Roubíček, Rate-Independent Systems: Theory and Application, Springer, New York, 2015.DOI
- [34]A. Moskovka, T. Rahman, J. Valdman, J. E. Vatne, Frameworking the vectorized basic linear algebra for prototyping codes in MATLAB, Applied Mathematics and Computation 513 (2026) 129778.
- [35]Matlab Central, Code for manuscript, https://www.mathworks.com/matlabcentral/fileexchange/, 2026. Last accessed: 25/10/2026.
- [36]B. D. Coleman, M. E. Gurtin, Thermodynamics with internal state variables, J. Chem. Phys. 47 (1967) 597–613.
- [37]G. A. Maugin, W. Muschik, Thermodynamics with internal variables. Part I. General concepts, J. Non-Equilib. Thermodyn. 19 (1994) 217–249.DOI
- [38]M. F. Horstemeyer, D. J. Bammann, Historical review of internal state variable theory for inelasticity, Int. J. Plasticity 26 (2010) 1310–1334.DOI
- [39]E. H. Lee, Elastic-plastic deformation at finite strains, Journal of Applied Mechanics 36 (1969) 1–6.
- [40]J. Simo, A framework for finite strain elastoplasticity based on maximum plastic dissipation and multiplicative decomposition. Part I. continuum formulation, Comp. Meth. Appl. Mech. Engrg. 66 (1988) 199–219.DOI
- [41]A. L. Eterovic, K.-J. Bathe, A hyperelastic-based large strain elasto-plastic constitutive formulation with combined isotropic-kinematic hardening using the logarithmic stress and strain measures, International Journal for Numerical Methods in Engineering 30 (1990) 1099–1114.DOI
- [42]D. Perić, D. R. J. Owen, M. Honnor, A model for finite strain elasto-plasticity based on logarithmic strains: Computational issues, Computer Methods in Applied Mechanics and Engineering 94 (1992) 35–61.DOI
- [43]C. Miehe, A constitutive frame of elastoplasticity at large strains based on the notion of a plastic metric, International Journal of Solids and Structures 35 (1998) 3859–3897.
- [44]J. C. Simo, T. J. R. Hughes, Computational Inelasticity, volume 7 of Interdisciplinary Applied Mathematics, Springer, Berlin, 1998.
- [45]V. A. Lubarda, Constitutive theories based on the multiplicative decomposition of deformation gradient: Thermoelasticity, elastoplasticity, and biomechanics, Applied Mechanics Reviews 57 (2004) 95–108.DOI
- [46]H. Xiao, O. T. Bruhns, A. Meyers, Elastoplasticity beyond small deformations, Acta Mechanica 182 (2006) 31–111.DOI
- [47]J. Friedlein, J. Mergheim, P. Steinmann, Observations on additive plasticity in the logarithmic strain space at excessive strains, International Journal of Solids and Structures 239-240 (2022) 111416.DOI
- [48]P. Neff, I.-D. Ghiba, A. Madeo, Loss of ellipticity for non-coaxial plastic deformations in additive logarithmic finite strain plasticity, International Journal of Non-Linear Mechanics 81 (2016) 122–128.arxiv.org/abs/1410.2819
- [49]W. Han, B. D. Reddy, Plasticity (Mathematical Theory and Numerical Analysis), number 9 in Interdisciplinary Applied Mathematics, Springer-Verlag, New York, 1999.DOI
- [50]K. Hackl, F. D. Fischer, On the relation between the principle of maximum dissipation and inelastic evolution given by dissipation potentials, Proc. R. Soc. A 464 (2008) 117–132.DOI
- [51]H. Petryk, Incremental energy minimization in dissipative solids, C. R. Mécanique 331 (2003) 469–474.
- [52]C. Miehe, M. Lambrecht, E. Gürses, Analysis of material instabilities in inelastic solids by incremental energy minimization and relaxation methods: evolving deformation microstructures in finite plasticity, J. Mech. Phys. Solids 52 (2004) 2725–2769.DOI
- [53]S. Stupkiewicz, H. Petryk, A robust model of pseudoelasticity in shape memory alloys, Int. J. Numer. Methods Engrg. 93 (2013) 747–769.DOI
- [54]B. Dacorogna, Direct Methods in the Calculus of Variations, Springer, Berlin, 1989.
- [55]J. M. Ball, Convexity conditions and existence theorems in nonlinear elasticity, Arch. Ration. Mech. Anal. 63 (1977) 337–403.DOI
- [56]A. Mielke, Evolution of rate-independent systems, in: C. M. Dafermos, E. Feireisl (Eds.), Handbook of Differential Equations: Evolutionary Equations, volume 2, Elsevier/North-Holland, Amsterdam, 2005, pp. 461–559.DOI
- [57]A. Mainik, A. Mielke, Existence results for energetic models for rate-independent systems, Calc. Var. Partial Differential Equations 22 (2005) 73–99.DOI
- [58]A. Mainik, A. Mielke, Global existence for rate-independent gradient plasticity at finite strain, J. Nonlin. Sci. 19 (2009) 221–248.
- [59]P. Neff, J. Lankeit, I.-D. Ghiba, R. J. Martin, D. Steigmann, The exponentiated Hencky-logarithmic strain energy. Part II: Coercivity, planar polyconvexity and existence of minimizers, Zeitschrift für angewandte Mathematik und Physik 66 (2015) 1671–1693.DOI
- [60]P. G. Ciarlet, The Finite Element Method for Elliptic Problems, SIAM, Philadelphia, 2002.
- [61]G. Strang, G. Fix, An Analysis of the Finite Element Method, second ed., Wellesley-Cambridge Press, Cambridge, 2008.
- [62]K.-J. Bathe, Finite Element Procedures, Klaus-Jurgen Bathe, 2006.
- [63]J. Simo, A framework for finite strain elastoplasticity based on maximum plastic dissipation and multiplicative decomposition. Part II. computational aspects, Comp. Meth. Appl. Mech. Engrg. 68 (1988) 1–31.DOI
- [64]T. Světlík, R. Varga, L. Pospíšil, M. Čermák, Interface between ANSYS and MATLAB for solving elastic problems with non-conforming meshes, in: International Conference of Numerical Analysis and Applied Mathematics: ICNAAM 2022, volume 3094, AIP Publishing, Melville: USA, 2024, p. 300005.
- [65]J. Karátson, S. Sysala, M. Béreš, Quasi-Newton iterative solution approaches for nonsmooth elliptic operators with applications to elastoplasticity, Computers and Mathematics with Applications 178 (2025) 61–80.DOI
- [66]S. Sysala, M. Béreš, B. Bérešová, T. Luber, Z. Michalec, Advanced continuation and iterative methods for slope stability analysis in 3D, Computers & Structures 315 (2025) 107842.
- [67]B. S. S. Tuchwiga, J. Krmela, J. Pokorny, V. Krmelová, P. Jilek, Vectfem: a generalized MATLAB-based vectorized algorithm for the computation of global matrix/force for finite elements of any type and approximation order in linear elasticity, Zeitschrift für angewandte Mathematik und Physik 75 (2024) 150.DOI
- [68]Zenodo repository, Software for the manuscript, 2026. doi:10.5281/zenodo.2366410, last accessed: 28/10/2026.DOI
- [69]K. Lewandowski, D. Barbera, P. Blackwell, A. H. Roohi, I. Athanasiadis, A. McBride, P. Steinmann, C. Pearce, Ł. Kaczmarczyk, Multifield finite strain plasticity: Theory and numerics, Comput. Methods Appl. Mech. Engrg. 414 (2023) 116101.DOI
- [70]A. M. Wahl, Mechanical Springs, Penton Publishing Company, Cleveland, OH, 1944.
- [71]H. Kato, H. Suzuki, Nonlinear deflection analysis of helical spring in elastic–perfect plastic material. Application to the plastic extension of piano wire spring, Mechanics of Materials 160 (2021) 103971.DOI
- [72]M. Frost, M. Ševčík, L. Kadeřávek, P. Šittner, P. Sedlák, Reconstruction of phase distributions in NiTi helical spring: comparison of diffraction/scattering computed tomography and computational modeling, Smart Mater. Struct. 29 (2020) 075036.DOI
- [73]C. Carstensen, A. Schröder, S. Wiedemann, An optimal adaptive finite element method for elastoplasticity, Numerische Mathematik 132 (2016) 131–154.DOI
- [74]P. Bammer, L. Banz, A. Schröder, Mixed finite elements of higher-order in elastoplasticity, Applied Numerical Mathematics 209 (2025) 38–54.arxiv.org/abs/2401.09080
- [75]A. Moskova, J. Valdman, Fast MATLAB evaluation of nonlinear energies using FEM in 2D and 3D: nodal elements, Applied Mathematics and Computation 424 (2022) 127048.DOI
- [76]M. Frost, P. Sedlák, L. Heller, L. Kadeřávek, P. Šittner, Experimental and computational study on phase transformations in superelastic NiTi snake-like spring, Smart Mater. Struct. 27 (2018) 095005.DOI
- [77]W. Tong, Plastic surface strain mapping of bent sheets by image correlation, Experimental Mechanics 44 (2004) 502–511.DOI
- [78]V. Chandra, N. P. Gurao, P. Chakraborty, A combined physical and virtual digital image correlation technique for calibration and validation of elasto-plastic-damage models, Experimental Mechanics (2024).DOI
- [79]Zenodo repository, Data for the manuscript, 2026. doi:10.5281/zenodo.23665563, last accessed: 28/10/2026.
