Tensor Calculus with Object-Oriented Matrices for Numerical Methods in Mechanics and Engineering

The main goal of the book is to establish a synthesis between classical matrix and tensor methods, and modern software technology. To achieve this, the approach involves the development of a cohesive methodological framework using object-oriented methods. This framework enables the seamless transformation of the theoretical modeling principles of mechanics into numerical computational programs for solving engineering problems. This is done without encountering methodological inconsistencies in various subareas. One classic example of such a challenge is the symbolic notation of tensor and matrix calculus, which features complex syntax and semantics. This notation, originally designed for 2D media, is still widely used today, especially in the form of matrix arithmetic. Despite the availability of multidimensional arrays in programming languages for matrix implementation, this notation remains prevalent.

Consequently, the well-established index notation for tensors and matrices becomes invaluable when specifying array objects within matrix operations. It may appear less popular due to the extensive use of sub- and super-indices. However, when applied with Einstein’s summation convention, it becomes highly effective and allows for transparent handling of multidimensional matrix operations, akin to ordinary scalar objects. Therefore, the introductory chapters explicitly introduce both symbolic and index notations to get readers acquainted with both notations in detail.

Index notation has grown immensely important for implementing tensor and matrix methods in object-oriented software designs. Multidimensional objects can be effectively implemented using specialized class structures in programming languages like C++ or Java. Compared to algorithmic programming languages such as C or FORTRAN, the object-oriented paradigm offers several advantages in declaring and defining tensor and matrix objects, as detailed by [Breymann 1997]. Some of the key topics covered in the book include:

- Declaration and definition of new class members in structured and related classes,

- Encapsulation of class member data and functions in private or protected areas (hidden and not accessible to the user),

- Definition of public interfaces for communication with class members (e.g., by calling functions),

- Inheritance of properties between class relations,

- Dynamic generation and deletion of new class instances during run time, and additionally, C++ allows for:

- Overloading of arithmetic and functional operators as per its language specifications.

Using these features, matrix operations can be implemented similarly to familiar scalar operations. These aspects of the approach are described and utilized in Chapter 3, considering the relevant properties of matrices and tensors outlined in Chapters 2 and 4. Finally, the practical application of the synthesized tensor/matrix methods is demonstrated through two typical software examples for Finite Element Method (FEM) applications in Chapter 7.

The primary objective of the book adheres to the rigorous approach that tensors, widely used in the context of consistent theories of mechanics and physics, should also be effectively utilized for numerical computations through object-oriented matrix methods in engineering. As such, it assumes a strong foundation in matrix and software methods, which are discussed in subsequent chapters.

In this introductory chapter, the essential fundamentals of classical matrix calculus are compiled, as outlined in [Zurmuehl/Falk 1986] and [Pestel/Leckie 1963]. The primary objective is to acquaint the reader with index notation for multidimensional matrices, which will serve as the basis for all arithmetic operations in the subsequent context. This introduction aims to make the reader comfortable with this notation, which may seem unfamiliar compared to traditional symbolic notation found in related publications. Another important aspect is the generalization of the conventional notation, primarily limited to one- and two-dimensional matrices, which was originally designed for manual computations on traditional media. Therefore adequate formulations for multidimensional matrices are crucial, especially by use of programming languages in the mathematical-scientific field that handle arrays of several dimensions using standard implementations. This introduction to index formulations also prepares the reader for the subsequent acquaintance with covariant and contravariant tensors in the following chapters on tensor analysis and computational tensor/matrix methods.

In this chapter on object-oriented matrices, we first focus on the structure and storage of multidimensional matrices, which are also mapped by applications on digital von Neumann computers into one-dimensional physical main memory. The section on hypermatrices explains this context and presents different representations for multidimensional matrices with the corresponding mathematical mapping rules. The representation of matrices is followed by the exemplary implementation of multidimensional matrices and vectors in object-oriented matrix classes, like MATRIZEM,MATRIX and VEKTOR, using the programming language C++. The primary goal is to demonstrate the organization of matrix objects in suitable class structures according to the object-oriented principles of encapsulation, inheritance, and communication interfaces of public functions. Readers may extend their knowledge of object orientation in C++ by studying relevant literature, such as [Rumbaugh/Blaha/Premerlani/Eddy/Lorensen 1991] on object-oriented modeling or like [Breymann 1997] on C++, as well as conduct research on the Internet. In addition to generating and managing static and dynamic matrix objects, it is particularly important to recognize the advantages of operator overloading in the presented approach. This allows for an intuitive and transparent handling of the new matrix objects for arithmetic and functional operations. These aspects will be demonstrated in Chapter 7 through two typical FEM-application algorithms implemented using tensor and matrix objects.

Tensor calculus, with its consistent formulation of invariants and transformations, has acquired a high significance in engineering over the years. Thus, early works on the mechanics of load-bearing structures, such as [Green/Zerna 1954], which renewed the theory’s formulation, and mathematical compendia on tensor calculus in index notation, such as [Duschek/Hochrainer 1968], can serve as a basis at this point. In this chapter, we recapitulate the most important basics of tensor algebra in this context, especially to make the approach of object-oriented matrix calculus comprehensible and to provide the ability to apply the presented methodology consistently. This is because the index notation allows the arithmetic operations of tensor calculus to be seamlessly transformed into the practical numeric aspects of programming tools using the new object-oriented classes and methods of matrix calculus. This capability is demonstrated with the tensor class BASIS and its application in the numeric function METRIC.

With the mathematical fundamentals of tensor calculus and its object-oriented implementation in numerical algorithms described in the preceding chapters, the objects in three-dimensional Euclidean space have been captured. They can be managed accordingly and represented through transformations in different views. The illustrations shown clarified these relationships in the spatial context.

For more complex situations, there is generally the challenge of developing a spatial understanding of how the objects are arranged and how they relate to each other. This requires appropriate geometric models that can be spatially examined from different sights to understand the positioning of objects, detect errors, and exclude unauthorized collisions.

For this purpose parallel and central perspectives on technical objects are of common use in engineering. Therefore in the following sections, such a concept is converted into object-oriented methods and implemented in the adequate classes PERSPEKTIVE and PyPLOT with elementary graphic tools based on the universal programming language Python being available in Visual Studio [Microsoft 2023]. Its application is demonstrated with the graphics function BASES_3D. Figure 5.5 displays the intended clarity in a typical stereo vision.

In this chapter, the fundamentals of tensor analysis are compiled for use within the finite element method. Similar to the classical approaches such as [Klingbeil 1966], the differential geometry of the spatial bodies is treated first, followed by the mechanical fundamentals for the deformation of elastic continua. The tensor representations are then specialized to the finite element approximations for the modeling of the geometry and the description of the displacement fields. These explanations follow the classical compendia, such as [Zienkiewicz/Taylor 1989] or even the textbook [Meissner/Maurial 2000]. Here, however, they are consistently presented in the preferred index notation for matrices and tensors. Derived exemplary for numerical purposes are the matrix relations for the approximate spanning of the geometry of individual elements and for their stiffness relations under external loading as well as for the calculation of internal forces. Since the focus is primarily on the principle of matrix methodology, the plane continua of the plate theory are selected as a relatively transparent field of application. This is sufficiently complex, but nevertheless illustrative, in order to demonstrate the advantages of the new matrix methods with typical examples.

Finally, the application of object-oriented matrix calculus is presented in two sections about quadrilateral and triangular plate elements based on typical C++ routines. The numeric functions PARALLELOGRAM and TRIANGLE exemplify, in the source code, the calculations of differential geometries, stiffness matrix relationships, and internal forces for both finite elements. The computation of corresponding numerical results is also demonstrated. The elements discussed are a bilinear parallelogram element and a linear triangular element, each with abstracted elasticity parameters. This allows the verification of calculated results for deformations and stresses under tension and shear in an elementary way. The program code, kept simple and clear, primarily aims to demonstrate how the required matrix objects of the matrix classes can be created and managed. It also illustrates how tensor/matrix arithmetic can be handled intuitively and clearly with the overloaded syntax for matrix operations.

With the present concept, a comprehensive synthesis from theoretical tensor notation and traditional matrix calculus to new classes of matrices and object-oriented algorithms for mechanics and engineering problems was accomplished. This integral approach to the elementary tensor calculus of tensor bases has been realized with the tensor class BASIS, and was tested using the function METRIC. In this context, also graphical methods for the perspective representation of basis vectors and tensor quantities play a significant role in illustrating the correlation of these quantities in three-dimensional space. For this purpose, the graphic classes PERSPEKTIVE and PyPLOT were created and utilized with the function BASES_3D for three-dimensional stereo vision.

Baker 1991. Baker, A. J.; Pepper, D. W.: Finite Elements 1-2-3. McGraw-Hill, New York (1991)

Bathe 1986. Bathe, K.-J.: Finite-Elemente-Methoden. Springer, Berlin (1986)

Beyer 1977. Beyer, A.: Berechnung großflächiger Grundwasserströmungen mit Vertikalstruktur mit Hilfe der Finte Element Methode. Fortschritt-Berichte der VDI Zeitschriften Nr. 34, Reihe 4 Bauingenieurwesen, VDI-Verlag, Düsseldorf (1977)