Object-Oriented Finite Element Analysis by Graham Charles Archer BASc.

285 Pages·1998·0.54 MB·English

Object-Oriented Finite Element Analysis
by
Graham Charles Archer
B.A.Sc. (University of Waterloo) 1985
M.A.Sc. (University of Waterloo) 1986
A dissertation submitted in partial satisfaction of the
requirements for the degree of
Doctor of Philosophy
in
Engineering-Civil Engineering
in the
GRADUATE DIVISION
of the
UNIVERSITY of CALIFORNIA at BERKELEY
Committee in charge:
Professor Christopher Thewalt, Chair
Professor Gregory Fenves
Professor James Demmel
1996
The dissertation of Graham Charles Archer is approved:
University of California at Berkeley
1996
Object-Oriented Finite Element Analysis
Copyright 1996
by
Graham Charles Archer
Abstract
Object-Oriented Finite Element Analysis
by
Graham Charles Archer
Doctor of Philosophy in Civil Engineering
University of California at Berkeley
Professor Christopher Thewalt, Chair
Over the last 30 years, the finite element method has gained wide acceptance as a
general purpose tool for structural modeling and simulation. Typical finite element
programs consist of several hundred thousand lines of procedural code, usually written
in FORTRAN. The codes contain many complex data structures which are accessed
throughout the program. For the sake of efficiency, the various components of the
program often take advantage of this accessibility. For example, elements, nodes, and
constraints may directly access the matrices and vectors involved in the analysis to
obtain and transmit their state information. Thus they become intimately tied to the
analysis data structures. This not only compounds the complexity of the components,
by requiring knowledge of the data structures, but writers of new analysis procedures
must be aware of all components that access the data. Modification or extension of a
portion of the code requires a high degree of knowledge of the entire program.
Solution procedures and modeling techniques become hard coded. The resulting code
is inflexible and presents a barrier to practicing engineers and researchers.
1
Recoding these systems in a new language will not remove this inflexibility. Instead, a
redesign using an object-oriented philosophy is needed. This abstraction forms a stable
definition of objects in which the relationships between the objects are explicitly
defined. The implicit reliance on another component's data does not occur. Thus, the
design can be extended with minimal effort.
The application of object-oriented design to the finite element method has several
advantages. The primary advantage is that it encourages the developer to abstract out
the essential immutable qualities of the components of the finite element method. This
abstraction forms the definition of objects that become the building blocks of the
software. The class definitions encapsulate both the data and operations on the data,
and provide an enforceable interface by which other components of the software may
communicate with the object. Once specified, the object interfaces are frozen. It is
possible to extend the interface later without affecting other code, but it should be
noted that modifying the existing elements of an interface would require changes
throughout the rest of the program wherever the interface was used. The internal class
details that are needed to provide the desired interface are invisible to the rest of the
program and, therefore, these implementation details may be modified without affecting
other code. Thus, the design forms a stable base that can be extended with minimum
effort to suit a new task. Due to the encapsulation enforcement inherent in object-
oriented languages, new code will work seamlessly with old code. In fact old code may
call new code.
The system design and a prototype implementation for the finite element method is
presented. The design describes the abstraction for each class and specifies the
interface for the abstraction. The implementation of a class, and the interaction between
2
objects must conform to the interface definition. Furthermore, recognizing that most
finite element development involves the addition of elements, new solution strategies,
or new matrix storage schemes, special care was taken to make these interfaces as
flexible as possible. The flexibility is provided by an object that is responsible for
automatically and efficiently transforming between coordinate systems to relieve
element and solution writers from this task. Elements authors are free to work in any
convenient coordinate system rather than requiring them to use the degrees-of-freedom
described by the modeler. Similarly, the writers of new solution strategies need not deal
with any model specific details or transformations, but rather are presented only with
the equations to be solved. The transformation from element coordinate systems to
final equations, including the effects of constraints and equation reordering, is
transparently handled without element or solution writer intervention. This separation
of tasks also allows analysis objects to use any matrix storage scheme that is convenient
for that particular method.
3
Table of Contents
List of Figures.........................................................................................................viii
List of Tables..........................................................................................................xi
1. Introduction.......................................................................................................1
1.1 Problem.................................................................................................1
1.2 Objective..............................................................................................3
1.3 Object-Oriented Philosophy as a Solution..............................................4
1.4 Organization.........................................................................................5
2. Literature Review...............................................................................................7
2.1 G. R. Miller, et al...................................................................................10
2.2 T. Zimmermann, et al............................................................................11
2.3 Jun Lu, et al...........................................................................................12
2.4 J. W. Baugh, et al...................................................................................14
2.5 H. Adeli, et al.........................................................................................15
2.6 Discussion..............................................................................................16
3. Methodologies....................................................................................................19
3.1 Design Formalisms.................................................................................20
3.1.1 Design Intent...........................................................................20
3.1.2 Entity Relationship Diagrams...................................................20
3.1.3 Responsibility Description.......................................................21
3.1.4 Event Flow Diagram................................................................22
3.1.5 Interface Definition Table........................................................23
3.2 Implementation in C++..........................................................................24
3.2.1 Associations............................................................................25
iii
3.2.2 Inheritance...............................................................................26
3.2.3 Interfaces.................................................................................27
3.2.4 Libraries..................................................................................28
3.2.4.1 Container Classes......................................................29
3.2.4.2 Numerical Object Library..........................................30
3.3 Implementation Formalisms....................................................................30
3.3.1 C++ Interfaces.........................................................................31
3.3.2 Demonstration Code................................................................32
4. Object Model Design..........................................................................................35
4.1 Top Level Objects..................................................................................38
4.1.1 Model......................................................................................40
4.1.2 Map.........................................................................................42
4.1.3 Analysis...................................................................................48
4.2 Components of the Model......................................................................52
4.2.1 Degree of Freedom Group (Node)...........................................52
4.2.2 Element...................................................................................59
4.2.3 Material, Action/Deformation, and Constitutive Model............65
4.2.4 Constraint................................................................................70
4.2.5 Displacement Boundary Condition...........................................73
4.2.6 Load Case...............................................................................75
4.3 Handlers................................................................................................82
4.3.1 Constraint Handler..................................................................83
4.3.2 Reorder Handler......................................................................86
4.3.3 Matrix Handler........................................................................89
4.4 Utility Objects........................................................................................91
4.4.1 Geometry................................................................................91
iv
4.4.2 Numerical Objects...................................................................95
4.4.3 Augmented Vector and Matrix Objects....................................98
5. Behavior of High Level Classes..........................................................................104
5.1 Element.................................................................................................106
5.1.1 Element Geometry...................................................................106
5.1.2 Communication of Element Properties.....................................107
5.1.3 Element State..........................................................................109
5.1.4 Action/Deformation.................................................................110
5.1.5 Resisting Force........................................................................111
5.2 Constitutive Model................................................................................111
5.2.1 Material Data..........................................................................112
5.2.2 Action/Deformation.................................................................113
5.2.3 Constitutive Model State.........................................................115
5.3 Analysis.................................................................................................116
5.3.1 Analysis Constructors..............................................................117
5.3.2 Analysis State..........................................................................119
5.3.3 Assembly.................................................................................120
5.3.4 Treatment of Boundary Conditions..........................................121
5.4 Constraint Handler.................................................................................124
5.4.1 Transformation Theory............................................................124
5.4.2 Selection of Analysis Unknowns..............................................126
5.4.3 Data Types.............................................................................127
5.4.4 Implementation.......................................................................128
5.5 Map.......................................................................................................133
5.5.1 Example..................................................................................133
5.5.1.1 Transformation of a Stiffness Matrix.........................135
v
5.5.1.2 Processing of Responses..........................................138
5.5.2 Implementation.......................................................................139
6. Extensions and Examples.....................................................................................147
6.1 Examples of Analysis.............................................................................148
6.1.1 Linear Static Analysis..............................................................149
6.1.2 Nonlinear Static Event to Event Analysis.................................151
6.1.3 Nonlinear Static Analysis with Newton-Raphson Iteration.......155
6.1.4 Nonlinear Dynamic Analysis with Newton-Raphson
Iteration...........................................................................................157
6.2 Substructuring......................................................................................163
6.2.1 FeaSuperElement.....................................................................167
6.2.2 FeaSuperElementLoad.............................................................179
6.2.3 FeaSuperElementInitialState....................................................180
6.3 2D Beam Element With End Hinges......................................................181
6.3.1 Moment-Rotation Elastic-Perfectly Plastic Constitutive
Model..............................................................................................182
6.3.2 2D Rectangular Coordinate System........................................191
6.3.3 2D Beam Element With End Hinges.......................................196
6.4 Building a Model...................................................................................215
6.5 Using the Finite Element Program..........................................................220
6.5.1 Linear Static Analysis..............................................................221
6.5.2 Nonlinear Static Analysis.........................................................222
6.5.3 Nonlinear Dynamic Analysis....................................................225
7. Conclusions and Future Work.............................................................................229
7.1 Conclusions...........................................................................................229
7.1.1 Architecture............................................................................230
vi