Tensor-based matrices in geometrically non-linear FEM

INTERNATIONAL JOURNAL FOR NUMERICAL METHODS IN ENGINEERINGInt. J. Numer. Meth. Engng 2005; 63:2086–2101Published online 3 May 2005 in Wiley InterScience (www.interscience.wiley.com). DOI: 10.1002/nme.1343

Tensor-based matrices in geometrically non-linear FEM

V. V. Chekhov∗,†

Yalta Management University, 8, vul. Rudanskogo, Yalta, 98600 Crimea, Ukraine

SUMMARY

In the framework of the object-oriented paradigm, advantages of using the index-free tensor notationin combination with the concept of generalized tensor-based matrix are considered as being the mostcorresponding to the paradigm. The advantages reveal itself in the disappearance of a semantic gapbetween various stages of creation of FEM applications (theoretical inferences, use of the numericalmethods, object-oriented software implementation) and, as a result, use of the unified object modelin all the stages, as well as simplification of theoretical transformations. Based on the consideredapproach, a new FEM equation for large strain analysis is developed and its solution technique isoutlined. Copyright � 2005 John Wiley & Sons, Ltd.

KEY WORDS: FEM equation; large strain; object-oriented approach; tensor-based approach

INTRODUCTION

The object-oriented (OO) approach [1], intended for investigation, modelling and developmentof complex systems, has found numerous realizations in the theory and practice of the finiteelement method (FEM) at present time. In particular, the use of OO approach proves to be ratherefficient in the field of structural analysis for the geometrically non-linear computations [2–9],when complexity of the FEM concept is intensified by the complexity of non-linear mechanicalformulations. A semantic gap between tensor form (natural for non-linear solid mechanics) andthe matrix one (conventional for FEM and convenient for manipulation by standard techniquesof matrix algebra) represents rather vexed problem (in comparison with linear analysis). Inthe majority of publications (where the subject is obviously mentioned) this gap is overcomeby introducing a transformation between the tensor and matrix forms. Such transformationcan be made in deducing of equations (then only matrix objects are available in the objectmodel and tensors are presented implicitly by their components, e.g. in Reference [4]), or inthe program implementation when the object model contains both matrix and tensor layouts,e.g. in Reference [8]. Both methods need major intellectual and/or computational effort since,

∗Correspondence to: V. V. Chekhov, 14-11, vul. Shpolyanskoy, Simferopol 95034, Ukraine.†E-mail: [email protected]

Received 23 May 2004Revised 26 September 2004

Copyright � 2005 John Wiley & Sons, Ltd. Accepted 31 December 2004

TENSOR-BASED MATRICES IN GEOMETRICALLY NON-LINEAR FEM 2087

actually, they do not remove the gap. In Reference [5] tensor and matrix classes are declared(by means of inheritance) as kinds of the concept of a multidimensional array; as a result, thegap is removed. The presented paper is also devoted to elimination of the above-mentioned gapby introducing for tensors a uniform representation to be used both for theoretical developmentand for practical implementation. An approach similar to the one used in References [10, 11] isapplied. In particular, its advantages, expressing in simplification of deducing new theoreticalresults for non-linear FEM, are demonstrated in this work.

INVARIANT TENSOR OBJECTS

Though, practically each research devoted to the OO FEM implementation introduces its ownobject model distinguished from other models developed by other authors (since ‘the choiceof what components in a system are primitive is relatively arbitrary and is largely up to thediscretion of the observer of the system’ [1]), nevertheless it is possible to pick out a numberof the ‘standard’ objects that belong to the problem domain (finite elements, nodes, matrices,etc.), which are present practically in all its OO implementations. In particular, ones that belongto the most important objects for geometrically non-linear consideration are tensors.

Besides matrix form which is especially popular and present practically everywhere in FEMapplications, there are two more forms for representation of tensors in the state-of-the-arttensor calculus [12]. Component form, which looks like ‘a value having indices’, is used, e.g.in References [4–6]; moreover, in the latter two this form is the base of the overall objectmodel. In the index-free form, which is developed later than others, tensor has no free indicesand, nominally, it is a contraction of its components with corresponding vectors of a basis (e.g.A = Asteset ). This fact allows us to write down mechanical relations in highly compact andindependent from basis form [13, 14], then indices ‘do not occult’ physical essence of laws.Such form is used in References [7–9] (alongside with matrix one) as a part of the objectmodel for non-linear FEM.

For comparison of the above-mentioned forms from the OO point of view, it is necessaryto note that, conceptually, tensor is an invariant object in the space, which does not dependon selection of a co-ordinate frame and basis. Though, this is valid in all formulations, forthe component form, only a part of a tensor (components in some concrete basis), which isnot invariant, is formally used as the tensor. At the same time we have to keep inwardly theinvariance of the tensor, and the responsibility for its correct treatment is up to the user. The OOapproach must unload the person and shift the responsibility for implementation of an object tothe object. From this viewpoint, the matrix form is more convenient. However, in the theory, itis used as auxiliary one and does not quite meet the tensor paradigm: tensor is not a matrix yetsince it ‘contains’ infinitely many matrices (co- and contravariant components for all possibleco-ordinate frames). A matrix or a multidimensional array may be internal implementation ofa tensor (the tensor may be asked for it) but it must not represent the interface of the tensor.The mentioned drawbacks are absent in the index-free form where all indices and basis vectorsare hidden within the object and, actually, are details of its internal implementation. This justcorresponds to the OO paradigm. Due to extension of mathematical functions, the differentialand integral operator [12] handling of tensor objects becomes as evident as that with scalarreal quantities. Such objects are used as the unified representation of tensors and as the basefor the object model in References [10, 11]. Although these papers are not devoted solely to

Copyright � 2005 John Wiley & Sons, Ltd. Int. J. Numer. Meth. Engng 2005; 63:2086–2101

2088 V. V. CHEKHOV

the non-linear FEM, they justly assert that benefits of the used approach can also be utilizedfor non-linear problems. In this manner, the presented work can be considered as an extensionof this approach to the area of geometrical non-linearity.

Non-linear theory of elasticity in index-free form is very compactly stated in Reference [14].The present paper in notations bases substantially in this source together with References [13, 15].For example, such tensors as position vector, Hamilton’s nabla operator (first-rank tensors),identity (metric) tensor (second-rank tensor) look like

r = r(qs), ∇ = es ��qs

, 1 = �st eset = eses = eses

where qs are co-ordinates, es = �r�qs are vectors of a current basis, es are vectors of the reciprocal

one. First and second order tensors are denoted by bold face, higher order tensors—by boldface with explicitly indicated order at left superscript. Scalar product, double scalar product,etc. are denoted by appropriate number of dots. Direct product is denoted by no characters.For example, double dot product for second-order tensors has the next behaviour

p · · q = q · · p = pT · · qT = qT · · pT (1)

Extraction of a scalar from a tensor is a standard technique to achieve commutativity in longformulae

a = 1 · a = eses · a = es(es · a) (2)

Based on the definition of derivation of tensors with respect to a tensor argument [12, 14],rules for derivation of composite functions with respect to a first-order tensor can be written as

(�p)a = p�a + �pa

(p · q)a = (pa · es) · qes + p · qa

(p · · q)a = (pa · es) · · qes + p · · qa

(p−1)a = −p−1 · (pa · es) · p−1es

(3)

Index-free form of mechanical formulations

While considering geometrical non-linearity, it is necessary to distinguish an initial configurationof a body and the current configuration. Therefore all quantities relating to the former aredenoted with zero above. Tensors of the second and higher orders whose different indicescorrespond to different configurations (so-called double tensors [15]), are denoted by sequencesof 0 and t . These sequences indicate which configuration respective index refers to (0—initial,t—deformed). Quantities relating to the local frame of a finite element are denoted with �above. Below the required values and formulations of the theory of elasticity are given in theindex-free form.



Deformed state of a continuum is determined by the displacement vector u = r − 0r and the

tensor0∇r = 0

eses = 1 + 0∇u.‡ Polar decomposition of the deformation gradient

0∇r = 0� · 0t

O = 0t

O · � (4)

defines an orthogonal tensor0t

O specifying rotation of a material particle, and tensors0� =√

0∇r · ( 0∇r)T and � = 0t

OT · 0� · 0t

O—left (Lagrange’s) and right (Euler’s) stretch tensors, respec-tively.

Strain measures: the linear strain tensor

0� = 1

2 (0∇u + (

0∇u)T) = 12 (

0∇r + (0∇r)T) − 1 (5)

the Green (-Lagrange) strain tensor

0E = 0

� + 12

0∇u · ( 0∇u)T = 12 (

0∇r · ( 0∇r)T − 1) = 12 (

0�2 − 1) (6)

the Green strain tensor increment after cutting terms of higher order of smallness [16]

�0E = 1

2 (0∇�u · (1 + 0∇u)T + (1 + 0∇u) · ( 0∇�u)T) (7)

the Finger [14] (Cauchy–Euler [15]) strain measure

b = (0∇r)T · 0∇r = �2 (8)

From conjugated (by Hill) energetic pairs composing elementary work �� = �� · · �ε� (inReference [15] existence of 11 such pairs is described, in Reference [12] the approach isspecified with introducing quasienergetic pairs) let us consider three pairs: a pair

�� = 0t

P · · �(0∇r)T (9)

consisting of the deformation gradient and the Piola stress tensor

0t

P = J (0∇r)−1T · T (10)

where J = dv/d0v is the cubic invariant of the deformation gradient, T is the Cauchy stress

tensor; a pair

�� = 0T · · � 0

E (11)

consisting of the second Piola–Kirchhoff stress tensor

0T = J (

0∇r)−1T · T · ( 0∇r)−1 (12)

‡Tensor (0∇r)T is known as the deformation gradient.


2090 V. V. CHEKHOV

and the Green strain tensor (6); and, for geometrically linear case, the pair consisting of theCauchy stress tensor and the linear strain one (5)

�� = T · · �0� = T · · 0∇�u = T · · 0∇�r (13)

Constitutive equations: the Hook’s law

T = 4C · · 0� (14)

where 4C is elasticity tensor of the material (which formally would be more correctly designated

byt t004C since contracted indices must belong to the same configuration); an analog of the Hook’s

law for increments (7), (12)

�0T = 4 0

C · · � 0E (15)

the Finger constitutive equation for isotropic elastic body [14]T = 2J−1(0�1 + 1�b + 2�b2) (16)

where 0�, 1� and 2� are functions of invariants of b which are specified by used model ofmaterial.

The variational principle of stationarity of potential energy for a deformed elastic body under‘dead’ loading [14] (total Lagrangian formulation is chosen)∫

0v

�� d0v −

∫0v

0�k · �r d

0v −

∫f

0�

0f · �r d

0� = 0 (17)

where k and0f are, respectively, vectors of external body forces and ‘dead’ external surface

forces given on a part of surface denoted as f0�. Linearization of this principle for the total

Lagrangian formulation [16] looks like

∫0v

(�0T · · ( 0∇��u · (1 + 0∇u)T) + 0

T · · ( 0∇��u · (0∇�u)T)) d

0v −

∫0v

0� �k · ��u d

0v −

∫f

0��

0f

· ��u d0� +

[∫0v

0T · · (( 0∇��u) · (1 + 0∇u)T) d

0v−

∫0v

0�k · ��u d

0v−

∫f

0�

0f · ��u d

0�

]= 0

(18)

Generalized matrices and FEM approximation

As it was said in Reference [17], in FEM ‘matrix notation is a modification of direct tensornotation in which everything is placed in matrix form, with some trickery used if need be’.It is to say that for carrying out complicated symbolic transformations the matrix form doesnot possesses the ‘user-friendly interface’ and from the OO point of view this looks like the



interaction with the object via one of its possible implementations and ignoring its interface.Possibly, before appearance of OOP, this form was optimum for FEM software implementation(since it closely connected with the concept of a numerical array, which is sufficiently closeto interior organization of computers, whereas other abstractions, which are not related to thisdomain, were unimplementable at that time); however now it does not meet the current stateof software tools.

The use of more general concept of the matrix allows avoiding inconsistency between matrixform of FEM and tensor form of mechanical formulations. Such matrices should allow usingnot only numbers but also tensors as their components and self-contained objects. Possibilityof using such matrices was asserted as early as in Reference [10], however rather few re-searchers are still developing this approach. For example, the subject was slightly mentioned inReference [5], the tensor-based stiffness matrices for some finite element (FE) types was for-mulated in Reference [11]. In the presented work, the use of tensor-based matrices is appliedto a structure as a whole having abstracted from the FE types used. With the tensor-basedmatrices being used there is no mixing of interfaces of tensors and matrices that are objects ofdifferent nature. Therefore, although in References [5, 11] all indices are reduced to tensorialones, it is most convenient for matrix and tensor indices to explicitly use the different spaceshaving inherent properties (e.g. in matrices indices are not subdivided into subscripts and su-perscripts, as well as it is not accepted to omit a summation sign). To distinguish these spacesthe matrix indices (node and FE numbers) will be enclosed in square brackets. On writingFEM approximation in the tensor-based form, basis functions become second-order tensors.In this case approximation of an unknown vector of position of the deformed configurationlooks like

r(0r) =∑

i

(∑�

V[�i](0r))

· R[i] (19)

Here tensor V[�i] is basis function (shape function) pertaining to the �th FE and the ith gridnode (which is supposed to be identically equal to zero when the ith node does not belong tothe �th FE), R[i] is radius-vector of the ith node, outer summation comprises all nodal pointsof the structure, inner one—all FEs. By analogy with the matrix form of FEM, the shapefunction can be determined in more detail as a spherical tensor:

V[�i](0r) = N[�i](

�qj )1 (20)

where N[�i] is a scalar shape function depending on local co-ordinates of the element�qj . The

approximation (19) covers all FE types having translational degrees of freedom.Similar approximation is if displacement vector is chosen as unknown function

u =∑i

(∑�

V[�i])

· U[i] (21)

where U[i] =0R[i] − R[i] are nodal displacements. Based on (19) virtual displacement equals

�r = �u =∑i

(∑�

V[�i])

· �R[i] (22)


2092 V. V. CHEKHOV

TENSOR-BASED MATRIX FORM OF FEM EQUATIONS

The above formulations allow building FEM equations in the ordinary way. For example, inlinear-elastic case based on (17), (22), (14), (1), and symmetric property of the tensor 4C inthe last pair of indices, the system of equations looks like

∑j

∑�

∫0v[�]

(0∇V[�i] · 0

es) · · 4C[�] · ·0∇V[�j ] · 0

et d0v

0es

0et · U[j ] = f[i]

where i runs over numbers of all nodes of the structure, and

f[i] =∑�

(∫0v[�]

0�k · V[�i] d

0v +

∫f

0�[�]

0f · V[�i] d

0�

)(23)

reflects physical meaning of total vector of external load acting at ith node. In matrix notationthis is

[K] · {U} = {f}Here, the dot product operator refers to components of matrices and vectors, while matricesand vectors by itself obey the rules of common matrix multiplication. Stiffness matrix ofthe structure is given by assembling of appropriate element matrices [K] =∑

�[K[�]], and its

components are second-order tensors:

K[�ij ] =∫

0v[�]

(0∇V[�i] · 0

es) · · 4C[�] · · (0∇V[�j ] · 0

et ) d0v

0es

0et = Kst

[�ij ]0es

0et (24)

and components of column vectors of the right-hand side and the unknown are first-ordertensors, respectively, f[i] (23) and U[j ].

Similarly, for a geometrically non-linear analysis, use of the total Lagrangian on basis ofthe linearized variational principle (18) taking into account (22), (21), (15), and the symmetry

of �0T and of the tensor 4 0

C in the last pair of indices, results in a system of equations

([01K] + [2K]) · {�U} = {�f} + {��} (25)

where [2K] is the matrix of influence of initial stress

2K[�ij ] =∫

0v[�]

0T · · (( 0∇V[�j ] · 0

et ) · (0∇V[�i] · 0

es)T) d0v

0es

0et

and the matrix [01K]

01K[�ij ] =∫

0v[�]

((0∇V[�i] · 0

es) · (1 + 0∇u)T) · · 4 0C [�] · · ((

0∇V[�j ] · 0et ) · (1 + 0∇u)T) d

0v

0es

0et

is usually represented as the sum of the incremental stiffness matrix and the matrix of influenceof initial strains.

After assembly of the system of equations it is possible already to specify the basis and toconsider tensors in matrices as submatrices (having eliminated basic vectors from both parts of



the system). Thus the system can be considered as an ordinary matrix equation accessible forstandard methods of matrix algebra. In contrast to the purely matrix approach this one requiresno induced transformations of tensors to form extrinsic for them (such as column vector forstress tensor or rectangular matrix for nabla operator) and does not depend on kind of selectedco-ordinate frame.

In addition, commutativity of the double dot product for second-order tensors (1) allowsus to move elasticity tensor to the left border of the integrand in calculation of the stiffnessmatrix. Thus in many cases (when used material is isotropic or axes of anisotropy are uniformthroughout the FE) elasticity tensor can be moved beyond the integral sign. Thanks to that,numerical integration expenses should be reduced considerably, and software efficiency shouldbe improved. In the case of purely matrix notation of FEM ([K] = ∫ [B]T[D][B] dv) suchcommutativity is absent.

Conversion to local co-ordinates

Operation of integration throughout each FE is performed generally with change of variables andconversion to its local co-ordinates. It is easy to write down this conversion in tensor-based form

by means of relation0∇ = 0∇�

r · �∇ = (�∇0

r)−1 · �∇ (its prototypes can be found in Reference [14]).For example, an expression for the stiffness matrix of linear-elastic analysis (24) with alsotaking into account sphericity of shape functions (20) take the form which can be expressedby one of two ways

K[�ij ] =∫

0v[�]

234C[�] · · (

0∇�r · �∇N[�j ]

0∇�r · �∇N[�i]) d

0v

=∫

0v[�]

4C[�]1·1

3·2(

0∇�r · �∇N[�i]

0∇�r · �∇N[�j ]) d

0v (26)

where 234C is an isomer of the tensor 4C being derived by swap the second and the third indices,

and operator1·1

3·2

represents double dot product with explicitly specified numbers of contracted

indices (being counted in both directions from the operator, in this case usual operator · ·look like

1·1

2·2). Introducing of such operator is more advantageous then use of the isomer from

viewpoint of software implementation efficiency.

DEDUCTION OF NEW EQUATIONS USING TENSOR-BASED MATRICES

The basic purpose and the mechanism of application of the OO approach is to distributecomplexity of the system among levels of abstraction. Achievement of this goal is known toresult in lightening of programming as well as analysis, modelling and design of systems. Inapplication to FEM formulations it is expressed in simplification of handling with them. As aresult, finding of new theoretical results requires considerably smaller efforts since it allows todistract from redundant details.


2094 V. V. CHEKHOV

An example: deduction of FEM equations for large strains

As an example let us consider analysis with taking into account large strains. Incrementalequations such as (25) in the general case does not fit for large strains. This is because of bothlinearization of increments and approximateness of the law (15): when rotations are consideredas infinitesimals of order 1, strains are infinitesimals of order 2, hence the deformation gradient

according to (4) can be approximately regarded as the rotation tensor [15]: 0∇r ≈ 0t

O. In this casethe second Piola–Kirchhoff tensor (12) turns out to be the actual stress tensor turned to the

axes of the initial configuration:0T ≈ 0t

O · T · 0t

OT. This justifies the use of (15). In Reference [15]the admissible domain is referred to as ‘small strains under moderate rotations’. Even thougha significant part of engineering problems allows such linearization, there are problems wherethis approach is practically unusable (e.g. determination of state of a thick-walled hollow bodywhich has been turned inside out). In this case it is rational to try to consider general non-linearformulations describing a final state of the loaded body.

Similarly to the linear-elastic case, substitution of the FEM approximation (22) to the ex-pression of the variational principle (17) with taking into account the elementary work (9) aswell as the identity (1) gives a system of equilibrium equations:

∑�

∫0v[�]

0t

PT · · 0∇V[�i] d0v = f[i]

where f[i] are the load vectors (23). It is fairly easy to derive the system of FEM algebraicequations if to be limited to consideration of isotropic materials. In this case the sought systemis obtained as a result of consecutive substitution expressions (10), (16), and (19)

2∑�

∫0v[�]

(0�(∑

m

0∇V[�m] · R[m])−1 + 1�

∑j

(0∇V[�j ] · R[j ])T

+ 2�∑l

∑k

∑j

(0∇V[�l] · R[l])T · (

0∇V[�k] · R[k]) · (0∇V[�j ] · R[j ])T

)· · 0∇V[�i] d

0v = f[i]

or in the matrix notation:

{F({R})} = {0} (27)

where {F} is non-linear vector-function of vector of unknowns {R} being a sum of 4 terms

{F({R})} = {K({R})} + [L] · {R} + (([4][4M] · {R}) · {R}) · {R} − {f}The terms are: {K} is a non-linear member being column-vector of first-order tensors

K[�i] = 2∫

0v[�]

0�(∑

m

0∇V[�m] · R[m])−1 · · 0∇V[�i] d

0v

[L] is a matrix of second-order tensors

L[�ij ] = 2∫

0v[�]

1�(0∇V[�j ] · 0

es)T · · 0∇V[�i]0es d

0v



[4][4M] is a four-dimensional matrix (array) of fourth-order tensors

4M[�ijkl] = 2∫

0v[�]

2�((0∇V[�l] · 0

es)T · (0∇V[�k] · 0

et ) · (0∇V[�j ] · 0

ep)T) · · 0∇V[�i]0ep

0et

0es d

0v

{f} is the external load vector (23).

Solution technique

If the built system (27) is solved based on the Newton–Raphson’s method

{R}(k+1) = {R}(k) − [FR({R}(k))]−1 · {F({R}(k))} (28)

then we should know the matrix-derivative [FR] or approximate it by finite differences. The lattersignificantly raises computational costs for problems having large size. In the case in questionthe function {F} can be differentiated explicitly, by use of the apparatus of tensor argumentdifferentiation [12]. Use of the formulae (3) after carrying out necessary transformations yields

[FR] = [1D] + [2D] + [3D]where

1D[�in] = �K[�i]�R[n]

= 2∫

0v[�]

0�R[n]

(∑m

0∇V[�m] · R[m])−1 · · 0∇V[�i] d

0v

− 2∫

0v[�]

0�

((∑m

0∇V[�m] · R[m])−1 · (

0∇V[�n] · 0es)

·(∑

m

0∇V[�m] · R[m])−1

)· · 0∇V[�i]

0es d

0v

2D[�in] = ��R[n]

([L][�] · {R})[i] = 2∫

0v[�]

1�R[n](0∇V[�n] · R[n])T · · 0∇V[�i] d

0v

+ 2∫

0v[�]

1�(0∇V[�n] · 0

es)T · · 0∇V[�i]0es d

0v

3D[�in] = ��R[n]

((([4][4M][�] · {R}) · {R}) · {R})[i]

= 2∫

0v[�]

2�R[n]((0∇V[�l] · R[l])T

·( 0∇V[�k] · R[k]) · (0∇V[�j ] · R[j ])T) · · 0∇V[�i] d

0v


2096 V. V. CHEKHOV

+ 2∫

0v[�]

2�((0∇V[�n] · 0

es)T · (0∇V[�n] · R[n]) · (

0∇V[�n] · R[n])T

+ (0∇V[�n] · R[n])T · (

0∇V[�n] · 0es) · (

0∇V[�n] · R[n])T

+ (0∇V[�n] · R[n])T · (

0∇V[�n] · R[n]) · (0∇V[�n] · 0

es)T) · · 0∇V[�i]0es d

0v

It is possible to see, that with the Newton–Raphson’s method being used it is the mostconvenient to forgo the conversion to the componentwise representation of tensors and toregard all matrices as tensor-based ones as before. Otherwise it would be fairly problematicalto obtain a result, since the compact formulae (3) would be inapplicable.

The FEM equation (27) has been obtained with considering only effect of ‘dead’ externalloads. However, this equation enables to easily take into account some kinds of a followerload. For example, the variational principle (17) allows to add the term [14], which takes intoaccount the acting of constant pressure. Equation (27) can be updated in order to consider thisclass of a load.

ON PROGRAM IMPLEMENTATION

Program implementation of the index-free tensors and the relations based on them is in essencesubdivided into two cases—symbolic and numerical computations. Although combination ofthese techniques has certain advantages (in particular, availability for an user to determine hisown computational methods [18, 19]), in terms of increase in computational efficiency it isbetter to realize them separately, since their requirements are opposite each other.

Symbolic computations

Tensor-based mechanical symbolic computations with using standard facilities available in com-puter algebra systems (e.g. References [20, 21]) at present restricts us to the component or matrixrepresentation of tensors. To have an opportunity to manipulate tensors in index-free form, it isnecessary to combine collections of components and basis vectors into a single data structure.And program implementation of tensor formulae should take into account organization of thisstructure, i.e. as a matter of fact, it is necessary to create a class containing necessary fieldsand methods. It is possible to do this, for example, with using last versions of Maple (bymeans of the built-in concept of the ‘module’ [22]), or Prolog- or Lisp-like languages thateasily enable to implement symbolic computations with using arbitrary concepts.

Program implementation of symbolic computations has the following features: (i) Dimen-sion of problems is not large, requirement of computation speed is not critical; (ii) Formulaebeing handled are previously unknown, and objects can essentially vary during computation(in particular, tensors can change their basis and order). On this basis, high degree of poly-morphism is required for implementation, and the tensor class should contain all informationabout index-free representation (components, a basis, covariance property). For embodying this,structure of the class shown on the Figure 1 may be offered. Here size of arrays basis andsuperscripts is equal to the order of the tensor, and the array components has recursive



Figure 1. Internal implementation of tensor class for symbolic computations.

Figure 2. Internal implementation of tensor classes for numerical calculations.

nesting. Depth of this nesting equals to the order of the tensor: for a first-order tensor this isan array of 3 numbers, for the second-order this is the array of 3 arrays of 3 numbers, etc.Elements of the array basis may be symbolic variables or first-order tensors. Accordingly,tensor operations, such as dot product, now take sense of methods for the class. Tensor-basedmatrices can be implemented through the common matrices/arrays due to absence of strongtyping in symbolic computations.

Numerical calculations

Features of a program implementation of the numerical calculations are: (i) large dimensionsof problems, high requirements to computational efficiency; (ii) formulations under implemen-tation are preset and constant, there is no need to change an internal structure of tensors duringcomputation. Hence, it is better to depart from redundant polymorphism and to create separateclasses for tensors of different orders. Besides, owing to (ii), the basis vectors and the infor-mation about covariance property now can be eliminated from the implementation of tensorclasses, since actually all this is required only for carrying out the symbolic transformations, i.e.tensor classes under adaptation to numerical calculations on the inside become more similar tomatrices. Thus, usage of advantages of the matrix approach here is not rejected, it is just movedto the implementation level. An example of the framework of the tensor classes is given on theFigure 2 (higher order tensors are implemented in a similar manner). It is good for componentsof any tensor to be internally implemented by one-dimensional array. This improves efficiencyof algorithms such as copying, multiplication by a number, etc. For other algorithms this arraycan be easily treated as a multidimensional one (by means of address arithmetic). It should benoted that such implementation of the symmetric tensor of the second-order coincides with itsrepresentation in purely matrix FEM. In turn, internal implementation of the fourth-order tensorwith the symmetric property on the first and the last pairs of indices (such as the elasticitytensor) should be symmetric matrix 6 × 6 coinciding with the matrix of elastic constants fromanisotropic theory of elasticity. At that, the internal implementation of the double dot productof these tensors (used in the Hook’s law) proves to be ordinary matrix multiplication, whichrequires distinctly smaller number of computing operations.


2098 V. V. CHEKHOV

Use of self-contained tensor objects also gives other opportunities for increase of perfor-mance. Some of them are displayed in Reference [11]. The problem consists in optimal selec-tion of the most suitable data structures and algorithms at the level of internal implementationof the object model. For example, in some cases evaluation of tensor quantity (that is sub-stantially more expensive than for scalar one) can be effectively replaced by return of oneof results of previous calls (such technique is common in the field of symbolic computa-tions). For this purpose it is possible to use a binary tree or other data structure intendedfor the fast-access retrieval. A good example for this is shown in Figure 3: a case when amaterial is asked for its elasticity tensor is shown. Here the implementation of the methodgetElasticityTensor in the class StrainIndependentMaterial returns referenceto the single available tensor of elasticity. At the same time the implementation of this methodfor the class StrainDependentMaterial first of all looks for required result by the keysearch (here the key is the strain level) in the binary tree, and in case of success the methodreturns it. Only if the search fails, a new tensor object is evaluated, pushed to the tree, andthe result is returned. Optimal selection of feasible accuracy is capable of considerable raisingof efficiency (since after a sufficient number of calls failure of the search becomes improb-able), growth of number of finite elements in the model should increase useful effect of thealgorithm.

Program implementation of tensor matrices fundamentally does not differ from commonmatrices and can be generalized with use of templates.

To illustrate possibility of the program implementation of the given methodology, a sample ofan actual program code is demonstrated. For example, a subroutine implementing the integrand(26) looks as follows (in form of a C++ functional object):

class tLinearElasticAnalysis: public t1stepAnalysis{ . . .struct fIntegrand{mutable tNodalTensor2 Result;const tFinitElement &FE;fIntegrand(const tFinitElement &fe_, const tNodalTensor2& t_): Result(), FE(fe_)

{Result.LinkNodes(t_);}fIntegrand(const fIntegrand &i_): Result(), FE(i_.FE)

{Result.LinkNodes(i_.Result);}tNodalTensor2& operator()(const Tensor1& localCoord_)

{tTensor2 jacoby = FE.JacobyTensor(localCoord_);const real_t J = jacoby.Det();jacoby.Invert();tTensor1 grad1 = FE.DisplShapeGrad(result_.Node(1),localCoord_),

grad2 = FE.DisplShapeGrad(result_.Node(2),localCoord_);grad1.DotMultiply_left(jacoby);grad2.DotMultiply_left(jacoby);(Result = grad1.DirectProduct(grad2)) *= J;if (!FE.Material().isIsotropic())

Result.DotDotMultiply(FE.MaterialElasTensor(localCoord_),1,3);return Result;

}. . .

};



Figure 3. Schema of using of previous results for evaluation of elasticity tensor.

Here the type name of the functional object has prefix ‘f’, names of other classes have prefix‘t’, tNodalTensor2 is an auxiliary class derived from tTensor2 with addition of ad-dresses of two grid nodes. This class is introduced for convenience of interaction with thestiffness matrix. Sense of other types and objects is clear from their names and the context.The given fragment quite meets to the theoretical source to within syntax of the language.At that, direct implementation of formulae allows to be combined with effective numericalalgorithms. In particular, the above functional object is intended for use by any FE type inoperation of numerical integration (the code of an integrand is beyond the scope of FE classes,since the object model used here supposes that a FE does not ‘know’ what type of analy-sis uses him). For example, in case of one-dimensional FE the integration procedure looksas follows:

template <typename Tfun, typename Tres>inline Tres& t1D_FE::Integrate (Tfun function_, Tres& result_) const{fMultiply<Tres,real_t> integrand(function_,fCrossSecArea(*this));return Integrate1D(integrand,result_);}//--------------------------------------------------------------template <typename Tfun, typename Tres>Tres& t1D_FE::Integrate1D (Tfun function_, Tres& result_) const{tTensor1 localCoord(0.); result_ = 0.;for (vector<tFinitElement::tGaussCoeff>::const_iterator p = GaussCoeffs.begin();

p < GaussCoeffs.end(); ++p){localCoord.SetComponent(1,p->Coord);result_ += (function_(localCoord) *= (p->Weight * Jacobian(localCoord)));}

return result_;}

Template generalization of procedures similar to this allows to integrate by identical way bothtensor-functions and functions of other suitable types (up to arrays of tensors). Efficiency ofthe last sample can be increased by use of the C++ Standard Template Library (STL; thus thecycle should be replaced by the algorithm for_each and one more functional object [23]).Though this decreases clearness of the code (more precisely speaking, algorithmic clearnesstransforms into functional one), STL-based functional style of programming combines a high


2100 V. V. CHEKHOV

degree of abstraction with efficiency, and it rather promotes effective program implementationof the complicated tensor formulae.

The non-linear equations (27)–(28) can be implemented with use of the above methodology.In this case, relatively unusual feature is the presence of the four-dimensional matrix withoperation of threefold multiplication. Evidently, implementation of these equations should revealmany other interesting features.

CONCLUSION

The index-free form for tensors used in combination with the concept of tensor-based matricesas a basic model for FEM representation is the most meeting OO paradigm that allows unifyingall development stages of FEM applications. As a consequence,

• semantic gap between theoretical formulation of a problem and its software implementa-tion is eliminated, the need for conversion between tensor and matrix representations iseliminated;

• semantic gap between tensor form of equations and numerical methods for their solutionis eliminated, compactness of the index-free form of mechanical formulations and thematrix one of numerical methods are combined. Some of the methods turn out to bemore convenient for the immediate use in a tensor-based matrix form. For the rest: aftercompletion of the stage of matrix assembly, equations to be solved can be naturally treatedas purely matric;

• in generating FEM matrices, elasticity tensors of a material can be moved beyond theintegral sign. This fact raises efficiency of computing;

• theoretical formulations take a compact form, which is available for efficient implemen-tation by moving matrix form of tensors to the level of internal implementation. Besides,this form simplifies symbolic calculations and derivation of new analysis methods, that isespecially useful for non-linear problems. In particular,

• one equation, derived in the presented research, can be used for solving non-linear prob-lems under large strains beyond the reach of other methods.

REFERENCES

1. Booch G. Object-Oriented Analysis and Design with Applications. Addison-Wesley Longman Inc.: Amsterdam,1994.

2. Dubois-Pelerin Y, Pegon P. Object-oriented programming in non-linear finite element analysis. Computersand Structures 1998; 67:225–241.

3. Menetrey Ph, Zimmerman Th. Object-oriented non-linear finite element analysis: application to J2 plasticity.Computers and Structures 1993; 49(5):767–777.

4. Commend S, Zimmermann Th. Object-oriented non-linear finite element programming: a primer. Advancesin Engineering Software 2001; 32(8):611–628.

5. Jeremic B, Sture S. Tensor objects in finite element programming. International Journal for NumericalMethods in Engineering 1998; 41:113–126.

6. Jeremic B, Runesson K, Sture S. Object oriented approach to hyperelasticity. Engineering with Computers1999; 15:2–12.

7. Lages EN, Paulino GH, Menezes IFM, Silva RR. Non-linear finite element analysis using an object-orientedphilosophy—application to beam elements and to the cosserat continuum. Engineering with Computers 1999;15:73–89.



8. Zabaras N, Srikanth A. Using objects to model finite deformation plasticity. Engineering with Computers1999; 15:37–60.

9. Zabaras N, Srikanth A. An object-oriented programming approach to the Lagrangian FEM analysis oflarge inelastic deformations and metal-forming processes. International Journal for Numerical Methods inEngineering 1999; 45:399–445.

10. Miller GR. Co-ordinate-free isoparametric elements. Computers and Structures 1993; 49(6):1027–1035.11. Miller GR, Arduino P, Jang J, Choi C. Localized tensor-based solvers for interactive finite element applications

using C++ and Java. Computers and Structures 2003; 81:423–437.12. Dimitrienko JuI. Tensor Calculus. Vysshaya Shkola Publ.: Moscow, 2001 (in Russian).13. Simmonds JG. A Brief on Tensor Analysis. Springer: Berlin, 1997.14. Lurie AI. Non-Linear Theory of Elasticity. North-Holland: Amsterdam, 1990.15. Chernykh KF, Litvinenkova ZN. Theory of Large Elastic Strains. LGU Publ.: Leningrad, 1988 (in Russian).16. Washizu K. Variational Methods in Elasticity and Plasticity (3rd edn). Pergamon Press: Oxford, 1982.17. Felippa CA. Advanced finite element methods (ASEN 5367) Course Material. http://caswww.colorado.edu/

courses.d/AFEM.d/ (11 September 2004).18. Eyheramendy D, Zimmermann Th. Object-oriented symbolic derivation and automatic programming of finite

elements in mechanics. Engineering with Computers 1999; 15:12–36.19. Gomenyuk SI, Tolok AV, Tolok VA. Principles of a building of the instrumental system of the mechanics

problems analysis ‘FORTU-RANOK’. 20th CAD-FEM Users’ Meeting 2002. International Congress on FEMTechnology. Conference Proceedings, Friedrichshafen, 2002; 2:216.4.1–216.4.10.

20. Lindgren LE. Tensor analysis of deformation. Part 1—co-ordinates, motion and deformation gradient.http://www.mapleapps.com/categories/mathematics/tensors/html/deformation11.html (11 September 2004).

21. Yew CK, Boyle JT, Mackenzie D. A computer algebra based finite element development environment.Advances in Engineering Software 2001; 32:913–925.

22. Object-Oriented Programming, Polymorphism, and More in Maple 9.5. http://www.maple8.com/demo/

Programming/Programming.html (11 September 2004).23. Meyers S. Effective STL. Addison-Wesley Longman Inc.: Amsterdam, 2001.


Tensor-based matrices in geometrically non-linear FEM

Documents

Transcript of Tensor-based matrices in geometrically non-linear FEM