Development of a Polygonal Finite Element Solver

Development of a Polygonal Finite Element Solver and
Its Application to Fracture Problems
A thesis submitted to the Graduate School of the University of Cincinnati in partial
fulfillment of the requirements for the degree of
Master of Science
In the Department of Mechanical and Materials
Engineering of the College of Engineering and Applied
Science
July 2017
By
Mithil Kamble
Bachelor of Technology, VJTI, Mumbai University
2011
Committee Chair: Yijun Liu, PhD
Abstract
This study develops a polygonal finite element solver for 2-D crack propagation simulation along
with a meshing algorithm which creates necessary polygonal mesh.
The work starts with a brief literature review of historical development of computational fracture
mechanics. After reviewing multiple methods employed for modeling fracture problems,
Wachspress formulation is selected for constructing the polygonal finite element solver. Polygonal
interpolants are developed using Wachspress’ framework and validated using published results. A
polygonal meshing algorithm is also developed since conventional finite element meshers do not
support domain meshing using higher order polygons. The meshing algorithm is then used to create
the mesh and input files for the polygonal finite element solver.
The polygonal solver is validated using conventional patch tests. The accuracy and convergence
of the method is assessed using classical solid mechanics problems with known analytical
solutions. Next, ability to include cracks geometrically is added to the meshing algorithm. The
polygonal solver is updated with crack tracking and remeshing capability. A fracture problem is
solved using the developed subroutines.
i
ii
Acknowledgements
I would like to express my gratitude to Dr. Yijun Liu whose patient guidance and mentoring has
made this thesis possible. He has always been very supportive and encouraging throughout my
journey in the University of Cincinnati.
A special thanks to Dr. Vemaganti whose various courses provided me insights which have proved
be very helpful. I would also like to thank Dr. Woo Kyun Kim for agreeing to be on the defense
committee.
I would be remiss to not mention all my friends from the CAE Research Lab, Yoshisu Dojo and
Cincinnati who have had to suffer my sense of humor (or lack thereof). I have always found a
listening ear and a helping hand in them whenever it was needed.
I dedicate this thesis to my parents. None of this would be possible without their silent sacrifices.
iii
Table of Contents
1
Introduction ............................................................................................................................. 1
1.1
Background and Motivation ............................................................................................. 1
1.2
Computational Fracture Mechanics ................................................................................. 2
1.3
Crack Propagation Modeling Techniques ........................................................................ 3
1.3.1 Extended FEM (X-FEM) ............................................................................................... 3
1.3.2 Cohesive Zone Model .................................................................................................... 3
1.3.3 Scaled Boundary FEM (SBFEM) .................................................................................. 4
1.3.4 Polygonal FEM (PolyFEM) ........................................................................................... 4
2
1.4
Historical Review of Polygonal Finite Elements ............................................................. 5
1.5
Thesis Organization.......................................................................................................... 6
Shape Functions for Polygonal FEA....................................................................................... 7
2.1
Background ...................................................................................................................... 7
2.2
Development of Polygonal Shape Functions ................................................................... 8
2.3
Essential Properties of Shape Functions .......................................................................... 8
2.4
Barycentric Coordinates and Wachspress Shape Functions .......................................... 10
2.5
Improvements by Dasgupta ............................................................................................ 12
2.6
Algorithm to Calculate Wachspress Shape Functions ................................................... 14
iv
3
2.7
Validation of Formulation .............................................................................................. 15
2.8
Numerical Integration .................................................................................................... 18
Meshing Algorithm for Polygonal Meshes ........................................................................... 19
3.1
Background .................................................................................................................... 19
3.2
Meshing Algorithm ........................................................................................................ 20
3.2.1
Internal Nodes ......................................................................................................... 21
3.2.2
Boundary Nodes...................................................................................................... 22
3.2.3
Corner Nodes .......................................................................................................... 24
3.2.4
Special Case: Transition Nodes .............................................................................. 26
3.2.5
Creating Final Mesh ................................................................................................ 28
3.3
4
5
Polygonal Mesh Results ................................................................................................. 29
Numerical Verification ......................................................................................................... 31
4.1
Background .................................................................................................................... 31
4.2
Patch Test ....................................................................................................................... 32
4.3
First Benchmark Problem: Cantilever Timoshenko Beam ............................................ 35
4.4
Second Benchmark Problem: Circular Hole in a Plate .................................................. 40
4.5
Comments on the Results ............................................................................................... 45
Crack Propagation ................................................................................................................. 47
5.1
Background .................................................................................................................... 47
v
6
7
8
5.2
Including a Crack in the Polygonal Mesh ...................................................................... 48
5.3
Stress Intensity Factor .................................................................................................... 50
5.4
Crack Propagation Results ............................................................................................. 53
Discussion and Conclusion ................................................................................................... 56
6.1
A Summary of the Work ................................................................................................ 56
6.2
Comments on the Meshing Algorithm ........................................................................... 56
6.3
PolyFEA Accuracy and Convergence ............................................................................ 57
6.4
Domains with Multiple Cracks ...................................................................................... 58
6.5
Concluding Remarks ...................................................................................................... 59
Appendix ............................................................................................................................... 60
7.1
Polygonal Meshing Algorithm ....................................................................................... 60
7.2
Mesh Modification to Insert a Crack.............................................................................. 77
Bibliography ......................................................................................................................... 83
vi
List of Figures
Figure 2.1: (a) Adjoint of a polygon (b) Meyers expressed Wachspress Shape Functions in terms of areas formed by
nodes and internal points ............................................................................................................................................10
Figure 2.2: Numbering convention for nodes and sides of a polygon ..........................................................................14
Figure 2.3: Standard polygons used to derive shape functions ...................................................................................15
Figure 2.4: 3D plots of (a) P5 element, (b)-(f) shape functions 𝑁1- 𝑁5 .......................................................................16
Figure 2.5: Figure 2.4: 3D plots of (a) H6 element, (b)-(g) shape functions 𝑁1- 𝑁6....................................................17
Figure 2.6: Using triangular gaussian quadrature for integration ..............................................................................18
Figure 3.1: In a structured mesh, number of neighboring nodes is limited to six (as is the case with node 5) ............20
Figure 3.2: Centroids of original elements serve as nodes ...........................................................................................21
Figure 3.3: New nodes are created along the boundary to form pentagons ...............................................................23
Fig 3.4: Figure 3.4: Pentagon is formed around corner nodes with three neighbors...................................................24
Figure 3.5: Quadrilateral is formed around corner nodes with three neighbors .........................................................24
Figure 3.6: An ABAQUS mesh of a quarter model of plate with a hole contains a ‘transition node’ along .................26
Figure 3.7: A hexagon is formed around a transition node .........................................................................................26
Figure 3.8: The final mesh is a combination of quadrilateral, pentagonal and hexagonal elements ..........................28
Figure 3.9: Polygonal mesh of a plate with a hole with 81 and 8385 elements respectively ......................................29
Figure 3.10: Polygonal mesh of a beam with 63, 276 and 1111 elements respectively ..............................................30
Figure 4.1: Patch test problem configuration ..............................................................................................................32
Figure 4.2: Element patches used for testing (a) T3, (b) Q4, (c) P5 and (d) H6 elements ............................................33
Figure 4.3Representative displacement and stress contours obtained from the patch tests ......................................33
Figure 4.4: Timoshenko beam problem configuration .................................................................................................35
Figure 4.5: Polygonal meshes of the beam with mixed polygonal elements ...............................................................36
Figure 4.6: Contour plots axial stress σ_xx for mixed polygonal meshes ....................................................................37
vii
Figure 4.7: Convergence of maximum vertical displacement ......................................................................................38
Figure 4.8: Convergence of maximum σ_xx .................................................................................................................39
Figure 4.9: Convergence of L2-norm of relative error for u_y......................................................................................39
Figure 4.10: Circular hole in a plate, problem configuration .......................................................................................40
Figure 4.11: Polygonal meshes of the plate with mixed polygonal elements ..............................................................41
Figure 4.12: Magnified view of σ_xx contour around the hole ....................................................................................42
Figure 4.13: Convergence of maximum σ_xx ...............................................................................................................44
Figure 4.14: Convergence of L2-norm of relative error for σ_xx ..................................................................................44
Figure 4.15: Smoothening stress contours ...................................................................................................................45
Figure 5.1: Mode-I center crack propagation problem configuration .........................................................................47
Figure 5.2: (a) Crack propagation as modeled in modified natural (b): Modified polygonal mesh with seam which
would work for linear convex polygons (solid dots are overlapping nodes, whereas terminal dots are crack tips) ....48
Figure 5.3: Polygonal mesh created for crack propagation problem. The mesh is sufficiently refined around the crack
tip and along the expected propagation path. ............................................................................................................49
Figure 5.4: Crack tip coordinate system and nodes used to calculate SIF....................................................................50
Figure 5.5: Mesh transition during at successive steps during crack propagation ......................................................53
Figure 5.6: σ_yy contours Crack propagation at various loading steps .......................................................................54
Figure 6.1: A domain containing multiple randomly oriented cracks (Liu, 2017) juxtaposed with a structured focused
mesh created for a center crack problem in this study ................................................................................................58
viii
List of Tables
Table 4.1: L2-norm of the relative errors for the solutions obtained from the patch tests .........................................34
Table 4.2: % absolute errors in maximum u_y for Timoshenko beam problem ..........................................................38
Table 4.3: % absolute errors in maximum σ_xx ...........................................................................................................43
Table 5.1: Table developed by Isida to calculate SIF in finite plates ............................................................................52
ix
1 Introduction
1.1 Background and Motivation
Galileo Galilei’s diary reveals he conducted an experiment to test strength of iron wires of different
lengths in 16th century [1]. Although his observations revealing inverse relation between length of
the wire and its length carrying capacity would have to wait for a few centuries before being
understood completely, his experiment shows that researchers have tried to quantify strength of
engineering materials for a very long time. Newton’s achievement in the field of calculus spurred
research activity in the field of continuum mechanics. Classical solid mechanics framework
developed in a century after Newton forms the backbone of current understanding of strength of
materials.
Fracture mechanics has always been of great interest to researchers who try to quantify strength of
materials. Failure of various structures due to fracture has incurred loss of several billion dollars
in the USA alone [3] . Apart from the structural integrity perspective, understanding crack
propagation is vital for various conventional energy industries which use hydraulic fracturing [4].
Since the advent of computational solid mechanics techniques in the last century, fracture
mechanics has received even greater attention. With increasing computational abilities of local
computers and clusters, simulating complex crack problems which find applications in many
engineering fields is now possible.
The long-term objective of this study is to develop a capability to simulate crack propagation in
domain containing multiple randomly oriented cracks.
1
1.2 Computational Fracture Mechanics
Various approaches to model fracture mechanics problems at various time and length scales have
been proposed over the years. Many of the approaches employ finite element algorithm to simulate
crack propagation which was conceived in 1950s [4] and gained traction in 1970s. The approaches
to model fracture behavior can be broadly categorized in two groups based on representation of
the cracks in domains [5].
The first group consists of methods which model cracks geometrically in the model. In this group,
the crack propagation can either be prescribed or arbitrary. Often the crack is modeled as edges of
elements in finite element simulations, it is an instance of prescribed crack propagation model.
Arbitrary crack propagation is supported in several recent approaches like meshless methods [7],
boundary element methods [8] and adaptive finite element methods [9]. Arbitrary crack
propagation methods have gained popularity recently due to increased computational capabilities
[10].
In the second broad category, the cracks are not represented geometrically but rather through
modification of constitutive relation or kinematic relation. Representing crack through constitutive
relations became popular after inception of smeared crack approach where softening parameters
are included in constitutive relation to represent the weakening of material due to cracks [10].
Recent developments in this category include representation of crack propagation using evolving
phase fields [11]. Kinematic representation of crack can be done in finite element methods by
modifying the shape function formulation. Extended finite element method is an instance of
kinematic representation where enrichment function is added to interpolants to represent a crack
[12].
2
In the following section, we briefly discuss various fracture modeling methods considered for this
study.
1.3 Crack Propagation Modeling Techniques
1.3.1 Extended FEM (X-FEM)
Belytschko et al [13] proposed a technique called X-FEM wherein crack could be
represented independently of the mesh. The crack tip elements are enriched with special
functions which can capture singular stress fields around the crack tip. Discontinuity in the
displacement field is captured by level set method.
X-FEM has gained popularity due to elegant way of representing crack which completely
avoids computationally expensive remeshing. However, the method becomes
computationally expensive for multiple crack propagation problems as multiple level sets
are required to track each crack separately.
1.3.2 Cohesive Zone Model
Cohesive zone models were first conceptualized by Dugdale [14]. In this approach, a layer
of cohesive elements is inserted along the propagation path. A traction separation governs
the cohesive element behavior where traction reaches a peak during loading and reduces
beyond peak gradually to zero, representing weakening of material and complete
separation due to presence of crack.
Cohesive zone model allows for arbitrary crack propagation without modifying underlying
formulation like X-FEM or mesh like adaptive techniques. However, the crack always
3
propagates along element edges only. Hence cohesive model would have to be sufficiently
refined to simulate propagation of multiple cracks.
1.3.3 Scaled Boundary FEM (SBFEM)
Scaled boundary finite element method proposed by Song et al [15] offers computational
advantage by reducing a spatial dimension of the problem. It offers semi-analytical solution
which is continuous along the radial direction. This enables SBFEM to capture singular
fields around crack tip with a relatively coarse mesh.
SBFEM stiffness matrices are dense and involve analytical equations. The expressions to
retrieve stress and strain are complex compared to other methods like X-FEM or
conventional FEM.
1.3.4 Polygonal FEM (PolyFEM)
Wachspress’ work in 1970s exploring properties of barycentric coordinates in 1970s [16]
paved the way for development of polygonal finite element methods. Wachspress
generalized barycentric coordinates for polygons and polyhedrons are essentially finite
element interpolants [17] which can reproduce high gradient stress fields accurately.
As the remeshing algorithm is not constrained by the order of element after it is split, the
remeshing algorithm can be greatly simplified. Moreover, polygonal shape functions can
be directly implemented in conventional finite element algorithms. Therefore, PolyFEM
presents a promising prospect for simulating multiple crack propagation problems.
4
1.4 Historical Review of PolyFEM
In the last decade generalized barycentric coordinates have received attention initially due to their
application in computer graphics [17]. Soon they were employed in finite elements as interpolants.
Wachspress presented rational shape functions in his seminal work [16] which eventually started
a spur of research activity and many equivalent formulations like Floater’s mean value coordinates
[18], Sibson coordinates [19], Laplace coordinates [20] were presented. With continued research
interest over past two decades, PolyFEM is a well-established field which fiends application in
topology optimization, mesh generation and fracture mechanics [17]. Voronoi cell finite element
method was one of the earliest efforts to extend polygonal interpolants to finite element framework
[21] .
We select PolyFEM to explore crack propagation problem principally due to flexibility of
remeshing algorithm and its ability to seamlessly merge with existing finite element framework.
PolyFEM interpolants, once derived, can be integrated like conventional finite element
interpolants to derive strain displacement matrices and assembled in global stiffness matrix. This
provides us with an opportunity to start with a routine finite element code and incrementally add
increasingly higher order polygons to the solver without altering underlying framework.
For the present work, we used Wachspress rational shape functions for linear, convex polygons
due to the simplicity of formulation. Dasgupta [22] has improved on the original Wachspress
formulation, greatly simplifying the original expression by reducing it to an iterative process of
linear equation multiplication. The details of the formulations will be discussed in the next chapter.
5
1.5 Thesis Organization
After this brief review, we proceed to the formulation, development and validation of a polygonal
finite element solver along with complimenting meshing algorithm. The developed solver would
be eventually used to simulate a crack propagation problem.
Following is a brief description of each of the chapters
Chapter 2 contains underlying mathematical formulation of Wachspress shape functions

Chapter 3 discussed meshing algorithm created to form polygonal meshes

Chapter 4 validates PolyFEM algorithm with convergence study

Chapter 5 includes an example of PolyFEM application to crack propagation problem

Chapter 6 discusses results and proposes modifications for future research

Chapter 7 contains an appendix of the polygonal meshing algorithm

Chapter 8 contains Bibliography
6
2 Shape Functions for PolyFEM
2.1 Background
Courant developed a procedure to construct approximate solution on an arbitrary domain with
supports on contagious triangles [23]. Triangular shape functions can approximate fields in
problems governed by potentials in the form of Laplace equation. Furthermore, approximating
complex shapes is easy with tessellation. Hence triangular elements are still widely used despite
reported issues in the accuracy. Taig introduced quadrilateral elements with quadratic shape
functions with aim of improving accuracy [24]. These two elements have been the backbone of
commercial packages since their inception. Concentrated efforts have made codes with the
conventional elements quite efficient. However, a systematic approach to extend and
commercialize the present formulation to polygonal elements seems to be lacking despite their
unique advantages.
Polygonal elements exhibit greater accuracy over conventional elements. They are less likely to
exhibit mesh locking. Furthermore, they enable flexibility in re-meshing procedure which could
be a significant factor in large deformation and crack propagation problems. Their unique
properties have prompted renewed developmental efforts. Recently a biomechanical model of an
eye was developed using polygons with 200 sides
[24]. Apart from finite elements, the
development of polygonal elements is of interest in diverse fields like computer graphics and
geometric modeling.
7
2.2 Development of Polygonal Shape Functions
Construction of shape functions necessary to calculate fields in polygonal region was the principal
problem which prevented development of polygonal elements. Wachspress achieved a
breakthrough by presenting a framework to generate shape functions for convex polygons with
any number of sides. The method enables generation of any arbitrary complex polygon with a
single subroutine. Warren extended the methodology to handle polyhedral volumes [26].
Sibson used Sibson coordinates to formulate polygonal shape functions [19]. More recently efforts
by Floater et al [18] as well as Sukumar et al [17] have resulted in formulations using mean value
and maximum entropy coordinates. Despite simplicity of the method, Wachspress’ shape functions
have received little attention. Algebraic nature of the equations has prevented researchers, who
predominantly work with C, C++ and Fortran, from developing the polygonal codes. Dasgupta has
developed an alternate methodology to compute Wachspress shape functions and developed a code
using symbolic mathematical package [22]. We intend to develop a code using Wachspress’ shape
functions and implement in a conventional FEA code using method developed by Dasgupta.
2.3 Essential Properties of Shape Functions
Let 𝛺 → 𝑅 2 be a 2D polygonal domain defined by 𝑛 interconnected nodes and corresponding
nodal coordinates (𝑥𝑖 , 𝑦𝑖 ). The shape functions 𝑁𝑖 map the scalar function 𝑢(𝑥) within the
domain. The shape functions map the scalar field using nodal values of scalar function, 𝑢𝑖 (𝑥). For
any arbitrary point ( 𝑥 , 𝑦 ) the interpolation can be represented as,
𝑛
𝑢ℎ (𝑥) = ∑ 𝑢𝑖 (𝑥) 𝑁𝑖 (𝑥)
𝑖=1
8
(0.1)
The shape functions must possess partition of unity to ensure that 𝑁𝑖 is non-negative and the rigid
body motion is accurately represented. Therefore,
𝑛
∑ 𝑁𝑖 (𝑥) = 1
(0.2)
𝑖=1
To reproduce nodal function values exactly and ensure that the interpolated values are bound
within the minimum and maximum of the nodal values, shape functions must have Kronecker delta
property. Hence,
𝑁𝑖 (𝑥𝑗 ) = 𝛿𝑖𝑗
(0.3)
For the scheme to be convergent, it is required that the first derivative of shape functions should
be at least continuously differentiable, i.e., they should be linearly complete. This condition can
be expressed as,
𝑛
∑ 𝑁𝑖 (𝑥)𝑥𝑖 = 𝑥
(0.4)
𝑖=1
These conditions in conjunction impose constraints on the formulation which must be followed to
develop a consistent finite element framework which can produce bounded and convergent results.
9
2.4 Barycentric Coordinates and Wachspress Shape Functions
(a)
(b)
Figure 2.1: (a) Adjoint of a polygon (b) Meyers expressed Wachspress Shape Functions in terms of areas formed by
nodes and internal points
For a polygonal domain
𝛺 → 𝑅 2 with 𝑛 interconnected nodes and corresponding nodal
coordinates (𝑥𝑖 , 𝑦𝑖 ), Barycentric or area coordinates are defined using weights with 𝑤𝑖 (𝑥) defined
over the region. Essential properties of Barycentric coordinates are partition of unity, linear
completeness and Kronecker Delta property. In finite element framework, Barycentric coordinates
are equivalent to shape functions. Therefore, Barycentric coordinates can be used to construct
shape functions in Galerkin methods. Barycentric coordinates are often expressed asф𝑖 (𝑥) =
𝑤𝑖 (𝑥)
𝑛
∑𝑗=1 𝑤𝑗 (𝑥)
(0.5)
Wachspress was the first person to construct rational shape functions using Barycentric
coordinates. As the shape functions are represented in the form of division of different polynomials
10
they are called rational shape functions. Wachspress shape functions for a polygon with 𝑛 nodes
take following form,
𝑁𝑖 (𝑥) =
ℙ𝑛−2 (𝑥)
ℙ𝑛−3 (𝑥)
(0.6)
Numerator ℙ𝑛−2 (𝑥) in the equation is proportional to the product of the line equation of the edges
excluding the two edges common to the node 𝑖. The denominator ℙ𝑛−3 (𝑥) is equation of the curve
passing through external intersection points (EIP), also known as adjoint of polygon (Fig 2.1 a).
EIP are the points formed by intersection of element edges when they are extended beyond nodes.
Determining adjoint of the polygon is non-trivial and a major hurdle in the formulation of
Wachspress shape functions.
Meyer et al developed the Wachspress formula further and demonstrated that the Wachspress
shape functions can be expressed in terms of areas formed by internal points and nodes (Meyer et
al 2002). Expression for shape functions obtained by Meyer is as follows,
𝑁𝑖 (𝑥) =
𝑤
̂ 𝑖 (𝑥)
𝑛
∑𝑗=1 𝑤
̂𝑗 (𝑥)
(0.7)
𝐴(𝑝𝑖 , 𝑝𝑗 , 𝑝𝑘 )
(0.8)
where,
𝑤
̂ 𝑖 (𝑥) =
𝐴(𝑝, 𝑝𝑖 , 𝑝𝑗 )𝐴(𝑝, 𝑝𝑗 , 𝑝𝑘 )
and, 𝐴(𝑝, 𝑝𝑗 , 𝑝𝑘 ) represents area formed by triangle (𝑝, 𝑗, 𝑘) etc. (Fig 2.1 b)
11
2.5 Improvements by Dasgupta
Dasgupta recognized that by imposing the condition that shape functions should behave linearly
on the boundaries, it is possible to come up with a general formula which can be implemented in
a single subroutine to calculate shape functions for any general convex polygon. The approach
developed by Dasgupta is summarized next.
Consider a convex n-gon 𝛺 → 𝑅 2 with the origin contain within its domain. The equation of
sides 𝑖 can be denoted by 𝑙𝑖 (𝑥, 𝑦). Since the origin is contained within the polygon, the general
equation of line can be expressed as,
𝑙𝑖 = 1 − 𝑎𝑖 𝑥 − 𝑏𝑖 𝑦 = 0
where,
and,
𝑎𝑖 =
𝑦𝑖 − 𝑦𝑖−1
𝑥𝑖−1 𝑦𝑖 − 𝑥𝑖 𝑦𝑖−1
(0.9)
𝑏𝑖 =
𝑥𝑖 − 𝑥𝑖−1
𝑥𝑖−1 𝑦𝑖 − 𝑥𝑖 𝑦𝑖−1
(0.10)
It is also worth noting that the polygonal domain is defined by, 𝛺 = ∪ { 𝑙𝑖 (𝑥, 𝑦) > 0} The
numerator is proportional to product of all 𝑙𝑖 (𝑥, 𝑦) excluding the two sides which contain the
node 𝑖. This ensures that the shape function vanishes on the all the other nodes. Therefore, the
shape function 𝑁𝑖 can be expressed as,
𝑗=𝑛
𝑁𝑖 ∝ ∏ 𝑙𝑗 (𝑥, 𝑦)
𝑗 ≠𝑖
𝑗 ≠𝑖+1
Weighting function 𝜙𝑖 (𝑥, 𝑦) can be introduced to obtain the following equation,
12
(0.11)
𝑗=𝑛
(0.12)
𝑁𝑖 = 𝜙𝑖 (𝑥, 𝑦) ∏ 𝑙𝑗 (𝑥, 𝑦)
𝑗 ≠𝑖
𝑗 ≠𝑖+1
To satisfy partition of unity we would need to find out all the 𝜙𝑖 (𝑥, 𝑦). However, if we introduce
scalar weights 𝑘𝑖 such that,
(0.13)
𝜙𝑖 (𝑥, 𝑦) = 𝑘𝑖 𝜙0 (𝑥, 𝑦)
The problem is now reduced to finding a 𝜙0 (𝑥, 𝑦) and scalars 𝑘𝑖 . And we have,
𝑗=𝑛
∑ 𝑘𝑖 ∏ 𝑙𝑗 (𝑥, 𝑦)
𝑛
(
𝑗 ≠𝑖
𝑗 ≠𝑖+1
=
1
𝜙0
(0.14)
)
And the expression for the shape function is,
𝑗=𝑛
𝑘𝑖
𝑁𝑖 =
∏ 𝑙𝑗 (𝑥, 𝑦)
𝜙0
(0.15)
𝑗 ≠𝑖
𝑗 ≠𝑖+1
Dasgupta used the linear behavior of shape functions on the sides of polygon to arrive at a generic
formula which can be recursively used to calculate values of 𝑘𝑖 . The value 𝑘1 is assumed to be 1
without loss of generality. To behave linearly on the sides,
𝑎𝑖+1( 𝑥𝑖−1 − 𝑥𝑖 ) + 𝑏𝑖+1( 𝑦𝑖−1 − 𝑦𝑖 )
𝑘𝑖 = 𝑘𝑖−1 (
),
𝑎𝑖−1( 𝑥𝑖 − 𝑥𝑖−1 ) + 𝑏𝑖−1( 𝑦𝑖 − 𝑦𝑖−1 )
13
𝑘1 = 1
(0.16)
With this basic framework, it is possible to code a single subroutine which can calculate shape
functions for an arbitrary convex polygon with any number of sides.
2.6 Algorithm to Calculate Wachspress Shape Functions
In a convex n-gone, 𝑛 vertices are defined by coordinates (𝑥1, 𝑦1 ), (𝑥2, 𝑦2 ), … . (𝑥𝑛, 𝑦𝑛 ). Vertices are
numbered in counterclockwise direction. Vertices (𝑖 − 1) and 𝑖 form the edge 𝑆𝑖 . Its equation is
given by equation (2.9). The required coefficients are calculated using equations (2.10), (2.11)
and (2.17).
Figure 2.2: Numbering convention for nodes and sides of a polygon
Numerator of the shape function 𝑁𝑖 is given by,
𝑗=𝑛
𝑁𝑢𝑚𝑖 = 𝑘𝑖 ∏ 𝑙𝑗 (𝑥, 𝑦)
𝑗 ≠𝑖
𝑗 ≠𝑖+1
14
(0.17)
And 𝑘𝑖 is calculated using equation 3. When all the coefficients and weights are found, the
Wachspress shape functions can be calculated using the formula,
𝑁𝑖 (𝑥, 𝑦) =
𝑁𝑢𝑚𝑖
∑ 𝑁𝑢𝑚𝑖
(0.18)
This general formula is applicable to all general polygons with 𝑛 ≥ 3.
2.7
Validation of Formulation
Figure 2.3: Standard polygons used to derive shape functions
The Mathematica subroutine was implemented and tried with conventional elements the results
with for T3 elements reduce to conventional FEA triangular shape functions. The results for a
general triangle and a standard bilinear quadrilateral element with origin at the center match the
conventional T3 and Q4 shape functions respectively.
The results for the pentagonal and hexagonal elements cannot be verified as no parallel exists in
established FEA formulation. The expressions become increasingly involved as the number of
edges increases and it could pose a problem in efficient implementation of the code. Hence it is
15
necessary to parameterize the equations so that a standard form for each polygon can be used which
can later be mapped to physical polygon to extract the fields. Expressions for shape function and
their contour plots for standard pentagon and hexagon are given ahead.
For a pentagon with vertices at (1, 1), (0, 2), (-1, 1), (-1, -1), (-1, 1):
N1 = −
N3 = −
N5 =
(1+x)(2+x−y)(1+y)
2(−7+x2 +2y)
,
N2 =
(−1+x)(1+y)(−2+x+y)
2(−7+x2 +2y)
,
(−1+x2 )(1+y)
−7+x2 +2y
N4 = −
(−1+x)(2+x−y)(−2+x+y)
2(−7+x2 +2y)
(2.20)
(1+x)(2+x−y)(−2+x+y)
2(−7+x2 +2y)
Figure 2.4: 3D plots of (a) P5 element, (b)-(f) shape functions 𝑁1 - 𝑁5
16
For a hexagon with vertices at (1, 1), (0, 2), (-1, 1), (-1, -1), (0, -2), (-1, 1):
N1 =
N3 =
(1+x)(−2+x−y)(2+x−y)(2+x+y)
4(−12+3x2 +y2 )
,
N2 = −
(−1+x)(−2+x−y)(−2+x+y)(2+x+y)
,
4(−12+3x2 +y2 )
N5 = −
(−1+x)(1+x)(2+x−y)(−2+x+y)
2(−12+3x2 +y2 )
,
N4 =
N6 =
(−1+x)(1+x)(−2+x−y)(2+x+y)
2(−12+3x2 +y2 )
(−1+x)(−2+x−y)(2+x−y)(−2+x+y)
4(−12+3x2 +y2 )
(1+x)(2+x−y)(−2+x+y)(2+x+y)
4(−12+3x2 +y2 )
Figure 2.5: Figure 2.4: 3D plots of (a) H6 element, (b)-(g) shape functions 𝑁1 - 𝑁6
17
,
,
(0.19)
2.8
Numerical Integration
Figure 2.6: Using triangular gaussian quadrature for integration
Numerical integration over polygonal domains is a critical step in polygonal finite element
procedure. Gaussian quadrature rules for triangular domains are well developed. However, their
extension for polygons is not trivial and a general framework to numerically integrate polygonal
domains is lacking. Therefore, already existing quadrature rules are frequently used in polygonal
finite element [29].
A convex polygon can be partitioned in triangles and an affine mapping transforms the physical
element triangles into a reference triangle. Isoparametric mapping can be used to find location of
Gaussian quadrature points in the physical element. The summation of evaluated values from each
triangle yields results for polygon,
𝑛
∫ 𝑓 𝑑𝛺 = ∑ ∫ 𝑓 |J𝑖 |𝑑𝛺
𝛺
𝑖=1 𝛥𝑖
High accuracy Gaussian quadrature rules developed by Dunavant are used in this study to perform
numerical integration (Dunavant , 1985).
18
3 Meshing Algorithm for Polygonal Meshes
3.1 Background
Algorithms to create conventional triangular or quadrilateral meshes over two dimensional
domains have been well researched and adopted in commercial finite element packages. However,
due to absence of widely used polygonal finite element solvers, creating polygonal finite element
meshes remains a relatively unexplored problem. Although algorithms used in the domain of
computer graphics often use polygons for topology optimization, their utility in creating polygonal
finite element meshes is limited. A self-contained Matlab® subroutine which creates polygonal
meshes has been developed by Talischi et al [31] . The subroutine uses Voronoi diagram in
conjunction with signed distance function to create polygonal mesh over several standard twodimensional domains. However, the lack of control over maximum permissible number of polygon
edges made the code unsuitable for this study.
To overcome the limitations, a Matlab® subroutine was developed which creates linear convex
polygonal mesh (limited till hexagon) using a structured linear triangular mesh. Following subsections discuss the general algorithm implemented and present few meshes created using the
subroutine. The Matlab code has been included in the appendix for reference.
19
3.2 Meshing Algorithm
Figure 3.1: In a structured mesh, number of neighboring nodes is limited to six (as is the case with node 5)
Pre-processing algorithm:




Read the input file containing structured linear triangular mesh
Store nodal coordinates and connectivity in x and node respectively
Loop through the nodes to construct num_of_neighbors and neighbor_list
Store centroidal coordinates of each element in poly_x, centroids will be nodes
in the polygonal mesh.
The meshing algorithm essentially uses centroids of the triangular elements shared by one node as
nodes of the polygonal mesh (Fig 2.1). Therefore, the maximum number of edges a polygon can
have is limited by the number of elements shared by individual nodes. In a structured triangular
mesh node shares maximum of six elements only. This automatically ensures that the polygonal
mesh generated will be limited to hexagons.
20
Forming a structured triangular mesh for most of the regular geometries is trivial and can be done
using any of the commercial finite element packages. In this study, the subroutine is designed to
read ABAQUS input file which contains a single instance of two-dimensional domain.
The subroutine runs different operations on nodes which are classified according to the number of
neighbors. Discussion on the different loops follows.
3.2.1 Internal Nodes
Figure 3.2: Centroids of original elements serve as nodes
Forming hexagons in the interior:

for k = 1: number interior_nodes
o Determine six elements which are shared by the node
o Update H6_node with the number of elements common to the node
(*no new nodes are created)
21
Nodes having six neighboring nodes are stored in the array interior_nodes. A loop runs through
the array and constructs hexagonal connectivity array H6_node by splitting elements which are
shared by the internal nodes. The element numbers of in the old mesh become node numbers in
the polygonal mesh. Most of the nodes in a large structured mesh are internal nodes, hence the
polygonal mesh created using this algorithm would be predominantly populated with hexagonal
elements.
3.2.2 Boundary Nodes
Forming pentagons along the edges:

for k = 1: number boundary_nodes
o Determine three elements which are shared by the node
o Create two new nodes at the midpoints of the element edges which lie
along the boundary
o Update poly_x with two newly created nodes
o Update P5_node with the number of elements shared by the node and
newly created node numbers
22
Figure 3.3: New nodes are created along the boundary to form pentagons
Nodes having five neighboring nodes are stored in the array boundary_nodes. Pentagons must be
formed around these nodes to form a smooth domain boundary. Each boundary node is shared by
three elements; hence three centroidal points are available to form a pentagon. The remaining two
points are obtained by splitting the two element edges which form the boundary of the domain. A
loop iterates this process and created a pentagonal nodal connectivity array P5_node.
23
3.2.3 Corner Nodes
Fig 3.4: Figure 3.4: Pentagon is formed around corner nodes with three neighbors
Figure 3.5: Quadrilateral is formed around corner nodes with three neighbors
24
Processing elements at the corners:

for k = 1: number corner_nodes
o Determine the number of neighbors the node has
if Neighbors = 2
 Identify two nodes created along corner edges of the element
while forming pentagons along the edge
 Create third node at the corner of the domain
 Update poly_x with newly created node
 Update Q4_node with the element number of the element at
the corner, identified edge nodes and newly created node
number
if Neighbors = 3
 Identify two nodes created along corner edges of the
elements while forming pentagons along the edge
 Create third node at the corner of the domain
 Update poly_x with newly created node
 Update P5_node with the number elements shared by corner
node, identified nodes and newly created node number
Nodes having three or fewer number of neighbors are stored in the array corner_nodes. The
corners would be split in either pentagons or quadrilaterals depending upon the number of
neighbors. A loop runs through the corner node array and forms appropriate polygon. As this
operation is performed after processing interior and edge nodes, no new nodes are formed. The
loop identifies nodes which were created earlier by splitting element edges which form the corners.
This avoids creation of duplicate nodes in the polygonal mesh. The corner node coordinates are
appended to poly_x to complete the re-meshing operation.
25
3.2.4 Special Case: Transition Nodes
Figure 3.6: An ABAQUS mesh of a quarter model of plate with a hole contains a ‘transition node’ along
Figure 3.7: A hexagon is formed around a transition node
26
Forming hexagons around transition nodes:

for k = 1: number transition_nodes
o Determine four elements which are shared by the node
o Identify two nodes created along boundary edges of the elements while
forming pentagons along the edge
o Update H6_node with the number elements shared by transition node,
and identified nodes
(*no new nodes are created)
Even while processing structured mesh, it is not possible to exclude all the irregularities. Especially
if the geometries include curved features like internal holes or cracks. The most common feature
of the meshes involving circular features is a line along which the diagonals of the triangular
element switch orientation. Intersection of such a line with curved boundary includes nodes which
have five neighboring nodes. A separate loop identifies such nodes and stores them in the array
transition_nodes. A loop running through this array adds hexagons to the array H6_node. Since
this is the last element formation loop to be executed, no new nodes are created here as well.
27
3.2.5 Creating Final Mesh
Figure 3.8: The final mesh is a combination of quadrilateral, pentagonal and hexagonal elements
Post-processing



Combine the arrays Q4_node, P5_node and H6_node in a nodal
connectivity matrix poly_node
Arrange the nodes of all the elements in counterclockwise direction
Create text file output which will be input to the PolyFEM solver with
appropriate boundary conditions
After all the nodes have been processed all the separate connectivity are combined in the array
poly_node which is the final nodal connectivity matrix. The subroutine loops through the
polygonal elements and re-arranges the nodes in counter-clockwise direction by calculating
individual angles relative to centroid of the elements. The subroutine also has provision to impose
28
displacement boundary condition as well as traction boundary conditions at pre-specified
locations. The mesh data and boundary condition data is written to a text file which will be read
by the PolyFEM solver as input.
3.3 Polygonal Mesh Results
Following are some results created using the meshing subroutine.
Figure 3.9: Polygonal mesh of a plate with a hole with 81 and 8385 elements respectively
29
Figure 3.10: Polygonal mesh of a beam with 63, 276 and 1111 elements respectively
30
4 Numerical Verification
4.1 Background
Patch tests have been conventionally used to assess accuracy and robustness of conventional finite
element codes [32]. Taylor et al [32] have shown patch tests to be necessary and sufficient
condition to ensure convergence of the method.
However, patch test might not be an ideal criterion to ascertain accuracy of polygonal element
formulation. Polygonal shape functions are often higher order polynomials which are integrated
over non-standard areas. As the numerical integration techniques do not exist for higher polygons,
the accuracy of the results is often compromised, unless specialized quadrature rules of high order
are used. Talischi et al [34] have demonstrated that polygonal elements often do not pass the patch
test owing to quadrature errors. Therefore, we have relied on simple patch tests only to ensure
numerical accuracy of the algorithm. Standards solid mechanics problems with known analytical
solutions were used to ensure convergence of the method.
Linearly elastic material behavior has been assumed for all the analyses presented henceforth.
Young’s modulus 𝐸 is set to be unity, whereas Poisson’s ratio 𝜈 is set at 0.3. All the problems have
been solved assuming plane stress conditions.
The convergence of the solution is assessed by calculating L2-norm of relative error of nodal
solutions. Following expression is used to calculate the L2-norm,
31
∑(𝜙𝑒𝑥𝑎𝑐𝑡 − 𝜙𝑐𝑎𝑙𝑐 )2
𝐿2 − 𝑛𝑜𝑟𝑚 = √
,
∑(𝜙𝑒𝑥𝑎𝑐𝑡 )2
(4.1)
where, 𝜙 is the calculated field variable under consideration.
4.2 Patch Test
For the patch test, a bi-linear plate is constrained with a roller support and a fixed node at one edge
while applying unit normal traction on the opposite edge (Fig 4.1). The patch should exactly
reproduce unit constant stress field in the loading direction and the analytical displacement fields
defined by𝑢𝑥 = 𝑥
(4.2)
𝑢𝑦 = −𝜈𝑦
(4.3)
As the polygonal elements cannot be represented in a square, they cannot be tested individually.
Hence, triangular elements are combined with polygonal elements to form a square patch. Element
patches depicted ahead (Fig 4.2) are used to run the patch test.
Figure 4.1: Patch test problem configuration
32
(a)
(b)
(c)
(d)
Figure 4.2: Element patches used for testing (a) T3, (b) Q4, (c) P5 and (d) H6 elements
Figure 4.3Representative displacement and stress contours obtained from the patch tests
33
L2 norm of relative
L2 norm of relative
error: ux
error: uy
Linear triangular element (T3)
1.7554 e-016
6.7738 e-016
Linear quadrilateral element(Q4)
3.0361 e-014
2.6048 e-014
Linear pentagonal element (P5)
2.7378 e-007
3.2418 e-007
Linear hexagonal element (H6)
2.0819 e-014
2.4022 e-014
Patch test
Table 4.1: L2-norm of the relative errors for the solutions obtained from the patch tests
The patch tests were able to reproduce constant stress fields linerly varying displacement fields.
Table 4.1 lists the error norms for nodal displacemnts. The error norm for the patch test of
pentagonal element was relatively higher compared to the other elements. The higher error can be
attributed to asymmetric nature of the pentagoanl element.
34
4.3 First Benchmark Problem: Cantilever Timoshenko Beam
Figure 4.4: Timoshenko beam problem configuration
Cantilever beam problem is a widely used to evaluate capabilities of finite element algorithms.
Timoshenko et al [35] have provided analytical solution for two-dimensional linearly elastic beam
subjected to quadratic shear tractions at one end. For a beam of length 𝐿 and height 𝐻 the
displacement and stress fields can be expressed analytically as (Augarde, 2008),
𝑃𝑦
𝐻2
2
𝑢𝑥 = −
[(6𝐿 − 3𝑥)𝑥 + (2 + 𝜈) (𝑦 − )]
6 𝐸𝐼
4
𝑢𝑦 = −
𝑃
𝐷2 𝑥
(3𝐿 − 𝑥)𝑥 2 ]
[3𝜈𝑦 2 (𝐿 − 𝑥) + (4 + 5𝜈)
6 𝐸𝐼
4
𝜎𝑥𝑥 =
𝑃(𝐿 − 𝑥)𝑦
𝐼
𝜎𝑦𝑦 = 0
35
(4.4)
(4.5)
(4.6)
(4.7)
𝜏𝑥𝑦
𝑃 𝐻2
= − ( − 𝑦2)
2𝐼 4
(4.8)
where 𝐼 is second moment of area of the beam cross section.
PolyFEA analyses with linear triangular, linear quadrilateral and mixed polygonal elements,
including pentagons and hexagons, were run with increasing mesh refinement. To compare the
performance with conventional finite element algorithms, the same benchmark problem was
simulated in ABAQUS with linear triangular and quadrilateral elements. The polygonal meshes
used and contour plots of axial stress are depicted in the following figures (Figs 4.5 and 4.6).
Figure 4.5: Polygonal meshes of the beam with mixed polygonal elements
36
Table 4.2 shows the absolute % errors in the maximum 𝑢𝑦 values obtained from the analyses. Figs
4.7 and 4.8 show the convergence of maximum 𝜎𝑥𝑥 and 𝑢𝑦 in analyses. L2-norm of vertical
displacement is plotted for PolyFEA analyses run using different element sets (Fig 4.9).
Figure 4.6: Contour plots axial stress σ_xx for mixed polygonal meshes
37
Mesh seed
Mesh seed
Mesh seed
Mesh seed
size: 0.5
size: 0.25
size: 0.125
size: 0.0625
PolyFEA: T3 elements
38.54
14.82
4.199
0.97
PolyFEA: Q4 elements
0.46
0.23
0.17
0.17
PolyFEA: Mixed mesh
12.82
4.31
1.13
0.11
FEA: T3 elements
38.55
14.82
4.20
0.97
FEA: Q4 elements
0.46
0.23
0.18
0.18
Mesh size v/s abs % error 𝒖𝒚
Table 4.2: % absolute errors in maximum u_y for Timoshenko beam problem
Figure 4.7: Convergence of maximum vertical displacement
38
Figure 4.8: Convergence of maximum σ_xx
Figure 4.9: Convergence of L2-norm of relative error for u_y
39
4.4 Second Benchmark Problem: Circular Hole in a Plate
Figure 4.10: Circular hole in a plate, problem configuration
Next, we consider a classic solid mechanics problem of square plate with a circular hole. Existence
of a hole causes stress concentration around the hole, resulting in high gradients in the fields.
Timoshenko et al [35] have provide analytical solution for the problem. Expressions for the
displacement and stress fields in polar coordinates are given below:
𝜎𝑎 𝑟
2𝑎
2𝑎3
𝑢𝑥 (𝑟, 𝜃) = −
[ (𝜅 + 1)𝑐𝑜𝑠𝜃 +
((1 + 𝜅)𝑐𝑜𝑠𝜃 + 𝑐𝑜𝑠3𝜃) − 3 𝑐𝑜𝑠3𝜃]
8𝜇 2
𝑟
𝑟
(4.9)
𝜎𝑎 𝑟
2𝑎
2𝑎3
𝑢𝑦 (𝑟, 𝜃) = −
[ (𝜅 − 3)𝑠𝑖𝑛𝜃 +
((1 − 𝜅)𝑠𝑖𝑛𝜃 + 𝑠𝑖𝑛3𝜃) −
𝑠𝑖𝑛3𝜃] (4.10)
8𝜇 2
𝑟
𝑟3
40
𝜎𝑥𝑥 (𝑟, 𝜃) = 𝜎 − 𝜎
𝑎2 3
3𝑎4
( 𝑐𝑜𝑠2𝜃 + 𝑐𝑜𝑠4𝜃) + 𝜎 4 𝑐𝑜𝑠4𝜃
𝑟2 2
2𝑟
(4.11)
𝑎2 1
3𝑎4
𝜎𝑦𝑦 (𝑟, 𝜃) = −𝜎 2 ( 𝑐𝑜𝑠2𝜃 − 𝑐𝑜𝑠4𝜃) − 𝜎 4 𝑐𝑜𝑠4𝜃
𝑟 2
2𝑟
(4.12)
𝑎2 1
3𝑎4
(
𝑠𝑖𝑛2𝜃
+
𝑠𝑖𝑛4𝜃)
+
𝜎
𝑠𝑖𝑛4𝜃
𝑟2 2
2𝑟 4
(4.13)
𝜏𝑥𝑦 (𝑟, 𝜃) = −𝜎
Quarter model of a bilinear plate with a central hole and width to radius ratio of 20 is modeled for
this purpose. The plate is constrained with roller boundary conditions on the symmetry edges while
applying unit normal traction on the right edge. Results from five different cases with varying
mesh density (Fig 4.11) are presented ahead.
Figure 4.11: Polygonal meshes of the plate with mixed polygonal elements
41
Figure 4.12: Magnified view of σ_xx contour around the hole
42
Mesh size v/s abs %
Mesh grid:
Mesh grid:
Mesh grid:
Mesh grid:
Mesh grid:
error 𝝈𝒙𝒙
4X2
4X4
4X8
8X4
8X8
PolyFEA: T3 elements
39.33
17.00
9.67
6.33
4.00
PolyFEA: Q4 elements
19.3333
4.6667
0.3333
1.3333
1.6667
PolyFEA: Mixed Mesh
41.67
22.33
11.67
7.67
2.67
FEA: T3 elements
39.67
17.00
9.33
6.333
1.0
FEA: Q4 elements
18.67
7.33
3.67
2.0
1.67
Table 4.3: % absolute errors in maximum σ_xx
Table 4.3 shows the absolute % errors in the maximum 𝜎𝑥𝑥 values obtained from the analyses. Fig
4.13 shows the convergence of maximum 𝜎𝑥𝑥 values in analyses. L2-norm of axial stress 𝜎𝑥𝑥 is
plotted for PolyFEA analyses (Fig 4.14).
43
Figure 4.13: Convergence of maximum σ_xx
Figure 4.14: Convergence of L2-norm of relative error for σ_xx
44
4.5 Comments on the Results
PolyFEA algorithm, when used with linear triangular and quadrilateral mesh, yield results which
agree with the results obtained from ABAQUS simulations. The analyses run with P5 and H6
elements show higher errors for coarse meshes. However, they perform better with refined meshes.
This can partially be attributed to the meshing algorithm which creates polygonal meshes where
pentagonal elements are always present along boundaries. Coarse meshes have higher fraction of
pentagonal elements in the mesh. As seen in the patch tests, pentagonal elements perform poorly
owing to the inherent asymmetry. Denser meshes, owing to lower fraction of pentagonal elements,
show improved performance.
Figure 4.15: Smoothening stress contours
Stress contours obtained from mixed polygonal mesh appear to be discontinuous, especially for
coarse meshes. The lack of smoothness in the contours can be attribute to the splitting of polygons
45
in linear triangles to plot contours. The contour fields become increasingly smoother with
refinement. However, some amount of jaggedness at the scale of smallest element size is always
present. The contours can be smoothened using algorithms available in packages like Tecplot.
Hence, the discontinuity in the stress contours does not result from nodal solution, instead from
the lack of availability of packages which can interpolate field variables over polygons.
46
5 Crack Propagation
5.1 Background
In this chapter, we use the PolyFEA code developed to simulate a simple Mode-I (opening) crack
propagation problem. A subroutine is added to the meshing algorithm to represent a horizontal
crack. A simplified re-meshing algorithm, which assumes horizontal crack propagation, is added
to the PolyFEA algorithm which simulates propagation in steps of fixed crack extension length.
Figure 5.1: Mode-I center crack propagation problem configuration
47
A rectangular plate of breadth 2𝑏, height 2𝑐 and a center crack length of 2𝑎 is constrained at the
bottom edge while normal unit tension 𝜎0 is applied on the top edge. A linearly elastic material
with Young’s modulus 100 units, theoretical fracture toughness (𝐾𝐼𝐶 ) 0.4 and Poisson’s ratio 0.3
has been considered with plane stress conditions for the propagation problem. Experimental
solution for the stress intensity factor (SIF) has been compared with the calculated SIF to assess
accuracy of the solution.
5.2 Including a Crack in the Polygonal Mesh
Figure 5.2: (a) Crack propagation as modeled in modified natural (b): Modified polygonal mesh with seam which
would work for linear convex polygons (solid dots are overlapping nodes, whereas terminal dots are crack tips)
As the shape Wachspress shape functions do not included modified formulation to account for the
stress singularities present at the crack tip like XFEM (Belytschko, 1999), cracks must be
represented geometrically in the domain. Formulations like modified natural neighbor interpolants
(Khoei, 2015) and conforming finite elements (Sukumar, 2004) can handle crack propagation
through cracks where crack tip can be present inside element area (Fig 5.2 (a)).
Wachspress shape functions are constrained in the sense that they cannot interpolate fields over
concave polygons. Moreover, since linear polygonal elements are used, crack tip cannot be present
along the element edge as is the case with. To accommodate these limitations, a subroutine
modifies the polygonal mesh by splitting interior hexagonal elements in pentagons by creating a
48
seam along the crack length (Fig 5.2 (b)). Duplicate nodes with traction free boundary conditions
are created along the crack length between crack tips as specified location.
Figure 5.3: Polygonal mesh created for crack propagation problem. The mesh is sufficiently refined around the
crack tip and along the expected propagation path.
To ensure that the mesh is sufficiently refined at the crack tip and expected propagation path, a
biased structured mesh was created in the ABAQUS (Fig 5.3). It should be noted that although
this approach would work for horizontal cracks, inclined cracks would need a different treatment
or a more general meshing algorithm which can handle unstructured meshes resulting from
complex crack geometries.
49
5.3 Stress Intensity Factor
Figure 5.4: Crack tip coordinate system and nodes used to calculate SIF
Presence in cracks in linear elastic materials leads to stress concentration and 1/√𝑟 singularities
in the stress fields around the crack tips [38]. Various analytical expressions are available to
describe fields around the crack tip, most popular of them being expressions derived by
Westergaard [38], Irwin [40] and Williams [41]. The presence of singular fields and corresponding
stress concentration is effectively captured by Stress Intensity Factor (SIF) 𝐾. Therefore, SIF
accuracy is an important parameter to assess accuracy of a crack propagation algorithm.
Leading term of the William’s expansion for dispalcement expression can be used to calculate SIF
[38] -
𝐾𝐼 =
𝐾𝐼𝐼 =
𝜇
2𝜋
√
𝑢𝑦
√1 + 𝜅 𝑟
𝜇
2𝜋
𝑢𝑥
√1 + 𝜅 𝑟
50
√
(5.1)
(5.2)
where, 𝜇 is the shear modulus, whereas, 𝜅 is (3 − 4 𝜈) for plane strain and (3 − 𝜈)/(1 + 𝜈)
for plane stress problems.
The expressions are applicable only to the 𝐾 −dominated region around the crack tip as the region
away from the crack tip is governed by the boundary conditions imposed. Hence, SIF extraction
technique proposed by Chan et al (Chan, 1970) is employed. Essentially, K is calculated at the two
closest nodes to the crack (Fig 5.4) and the values are linearly extrapolated to compute value of
SIF at the crack tip.
Following expression can be used to determine to calculate the crack propagation angle with
respect to local polar coordinates (Fig 5.4) which uses relative magnitudes of SIF to determine
propagation path [38] –
𝜃 = 2 tan−1 (
𝐾𝐼 − √𝐾12 + 8𝐾𝐼𝐼2
)
4𝐾𝐼𝐼
(5.3)
However, we limit the present study to the accurate calculation of SIF and crack propagation with
minimal remeshing. As a domain with horizontal crack is being pulled with normal traction, it can
be intuitively seen that the crack will propagate in horizontal direction. Hence, the remeshing
subroutine added to PolyFEM algorithm tracks crack tip and locates the next node situated at 𝜃 =
0 and shifts the crack tip to the node while splitting the old crack tip node in two if 𝐾𝑒𝑓𝑓 is greater
than 𝐾𝐼𝐶 . Calculated 𝜃 is used to calculate the effective SIF 𝐾𝑒𝑓𝑓 using following expression [38]𝜃
𝜃
𝜃
𝐾𝑒𝑓𝑓 = 𝐾𝐼 𝑐𝑜𝑠 3 ( ) − 𝐾𝐼𝐼 𝑐𝑜𝑠 2 ( ) 𝑠𝑖𝑛 ( )
2
2
2
51
(5.4)
The 𝐾𝐼 values obtained are compared with the SIF obtained from analytical solution. Isida [43]
has derived analytical expressions for a central crack problems which account for relative length
scales of the crack and plate. The general expression for a finite plate with a central crack is
expressed as𝐾 = 𝐹 𝑇 𝜎0 √𝑎
(5.5)
For plate with 𝑎/𝑏 ratio 0.1 and 𝑐/𝑏 ratio 0.5 (Fig 5.1), the value of coefficient 𝐹 𝑇 can be readily
retrieved from the table provided by Isida (Table 5.1)
Table 5.1: Table developed by Isida to calculate SIF in finite plates
For this study, following expression of SIF is used to calculate the analytical values.
𝐾 = 1.175 𝜎0 √𝑎
52
(5.6)
5.4 Crack Propagation Results
Figure 5.5: Mesh transition during at successive steps during crack propagation
53
Figure 5.6: σ_yy contours Crack propagation at various loading steps
A polygonal mesh with 6271 nodes is used to run the crack simulation algorithm. The simulation
is completed in 18 steps and the next step results in complete rupture of the plate. Time taken to
complete the simulation with one compute node on Homer cluster was 61 minutes.
54
The time taken to solve the propagation is quite high compared to other methods like XFEM which
can solve a similar propagation problem of comparable size in a minute on a regular desktop. A
potential reason for high computation time is discussed in following chapter.
The 𝐾𝐼 values obtained differ by 30 % in the worst-case scenario and remain within 10 % for all
the remaining steps. The error in the computed values can be partially attributed to the increase in
the element size as the crack tip moves towards the domain boundary, compounded by limitations
of pentagonal elements discussed in the previous chapter. Furthermore, the linear extrapolation
could add to the error as well. A more complex method involving fitting a quadratic or cubic curve
to greater number of elements near the crack tip could help in this regard.
55
6 Discussion and Conclusion
6.1 A Summary of the Work
In this work, we started with a review of various finite element schemes best suited for crack
propagation problems. Polygonal finite element algorithm was chosen owing to greater flexibility
it offers in the remeshing algorithm. For that purpose, Wachspress shape functions were derived
for various polygons and validated.
A meshing algorithm was developed which could create a polygonal mesh using structured mesh
created by conventional finite element packages. Then, Wachspress shape functions were
implemented in a static solver for linearly elastic materials. The solver was validated using a couple
of benchmark problems. A simple remeshing algorithm was added and implemented to simulate a
horizontal central crack propagation problem.
Next, we discuss the results in the context of key features of the project. Few changes that can be
implemented in future to improve the performance and make the algorithm more general are
proposed as well.
6.2 Comments on the Meshing Algorithm
The present solver can handle structured mesh with maximum of six neighboring nodes for each
node. Polygonal solving algorithm created by Talischi et al [30] presents a more genera approach
employing Voronoi tessellation. The maximum number of edges present in a polygon cannot be
limited in a general tessellation algorithm. However, since the present study limits itself at
56
hexagonal elements, the said meshing algorithm could not be employed. Wachspress shape
functions are derived using iterative process and hence theoretically does not have an upper bound
on number of edges in a polygon [22]. Therefore, the present algorithm can be updated with higher
order interpolants, thus making use of generic meshing algorithms possible.
Another important aspect critical to meshing algorithms is node numbering scheme. Extensive
literature exists which explores various node numbering schemes with the aim of reducing
bandwidth of the global stiffness matrix viz. nested dissection scheme [44]. The present algorithm
does not seek to optimize the node numbering. The duplicate nodes added for the crack propagation
problem, often to the elements which were created earlier in the algorithm, increase the band width
of the global stiffness matrix to make it comparable to the total global node number. The increase
in memory requirement adds to the computational cost of the remeshing algorithm which explains
high computational time required to simulate a simple crack propagation problem.
6.3 PolyFEA Accuracy and Convergence
Accuracy and convergence of the PolyFEA algorithm has been demonstrated in Chapter 4 through
benchmark problems. As observed previously, although polygonal elements suffer in terms of
accuracy for coarse meshes, their performance and matches conventional finite element solvers as
the mesh is refined. This is not a shortcoming of the method but possibly that of quadrature scheme.
We have derived Wachspress shape functions using original formulation proposed by Dasgupta
[22] which involve derivatives of high degree polynomials which can induce numerical errors in
quadrature. However, recent works have shown that Wachspress interpolants and their weights
can be expressed using simpler expressions [17] . Switching to simpler definition of the shape
function can possibly lead to lower errors and faster convergence.
57
6.4 Domains with Multiple Cracks
Figure 6.1: A domain containing multiple randomly oriented cracks (Liu, 2017) juxtaposed with a structured
focused mesh created for a center crack problem in this study
The eventual aim of the present work is to develop a PolyFEA algorithm which can simulate
multiple crack propagation problems. As discussed in the previous chapter, as the polygonal shape
functions do not have a built-in ability to represent singular fields in crack tip region, the cracks
must be included as geometrical features in the domain. If domain with multiple randomly oriented
cracks is to be modeled (Fig 6.1) the present meshing algorithm poses limitations.
Modified natural neighbor shape functions which support interpolation with concave, i.e. cracked,
polygons [36] could be more suited for this purpose. Another approach could be developing
quadratic Wachspress shape functions and having quarter point elements around the crack tip.
58
6.5 Concluding Remarks
In this work, we have successfully demonstrated convergence and accuracy of PolyFEA algorithm
using Wachspress interpolants. A supplementary meshing algorithm has been created which can
be used to create meshes for domains which can be meshed using mapped meshes in commercial
finite element packages. Crack propagation ability is added to the PolyFEA solver as well to
simulate a simple propagation problem. This study and modular subroutines developed in the
process can serve as a template to implement various polygonal interpolants and solve more
general crack propagation problems in the future.
59
7 Appendix
7.1 Polygonal Meshing Algorithm
close all
clc
%-----------------------------------------------------------% Open .inp file and create input file for the PolyFEM code:
%-----------------------------------------------------------disp ('Select the ABAQUS input file to be opened \n');
input_fid = fopen( uigetfile('.inp'), 'rt' );
clc;
prompt = 'Please enter the file name for input file to be created:\n ';
fileNametext = input(prompt,'s');
fileName=[fileNametext,'.dat'];
output_fid = fopen(fileName, 'wt');
clc;
%-----------------------------------------% Determine Element and Node neighbor_list:
%-----------------------------------------i=1;
while i>0
tline = fgets(input_fid);
i = ~strncmpi(tline,'*Node',5);
end
% Node neighbor_list:
% ----------nodenum = 0;
i=1;
60
while i>0
tline = fgets(input_fid);
if(strncmpi(tline,'*Element Connectivity:',8))
break
end
nodenum = nodenum + 1;
arr = str2num(tline);
x(nodenum,1) = arr(2);
x(nodenum,2) = arr(3);
end
% Element neighbor_list:
% ---------------------elemnum = 0;
i=1;
while i>0
tline = fgets(input_fid);
if(strncmpi(tline,'*',1))
break
end
elemnum = elemnum + 1;
arr = str2num(tline);
node(elemnum,1) = arr(2);
node(elemnum,2) = arr(3);
node(elemnum,3) = arr(4);
end
% Loop through connectivity and determine neighbour list for all the nodes:
%-------------------------------------------------------------------------num_of_neighbors = zeros(nodenum,1);
neighbor_list
= zeros(nodenum,3);
for k=1:elemnum
61
for i=1:3
for j=1:3
ii = node(k,i);
jj = node(k,j);
if(i ~= j)
nbi
= num_of_neighbors(ii);
icheck = 0;
for inode=1:nbi
if(jj == neighbor_list(ii,inode))
icheck = 1;
end
end
if(icheck == 0)
num_of_neighbors(ii) = num_of_neighbors(ii) + 1;
neighbor_list(ii,num_of_neighbors(ii)) = jj;
end
end
end
end
end
%-----------------------------------------------------------% According to the number of neighboring nodes sort the nodes
% in three categories:
%
1.Interior nodes
(6 neighboring nodes)
%
2.Transition nodes (5 neighboring nodes)
%
3.Boundary nodes
(4 neighboring nodes but not adjacent
%
%
to corner nodes)
4.Corner nodes
(3 or 2 neighboring nodes)
%-----------------------------------------------------------count_interior = 0;
count_boundary = 0;
count_semiboundary = 0;
62
count_corner = 0;
count_transition = 0;
for k = 1:nodenum
if (num_of_neighbors(k) == 6)
count_interior = count_interior + 1;
interior_nodes(count_interior) = k;
elseif ((num_of_neighbors(k) == 4) && ...
~(any((num_of_neighbors(nonzeros(neighbor_list(k,:))))<4)))
count_boundary = count_boundary + 1;
boundary_nodes(count_boundary) = k;
elseif ((num_of_neighbors(k) == 4) && ...
(any((num_of_neighbors(nonzeros(neighbor_list(k,:))))<4)))
count_semiboundary = count_semiboundary + 1;
semiboundary_nodes(count_semiboundary) = k;
elseif (num_of_neighbors(k) == 5)
count_transition = count_transition + 1;
transition_nodes(count_transition) = k;
else
count_corner = count_corner + 1;
corner_nodes(count_corner) = k;
end
end
if (count_interior == 0) interior_nodes = 0 ; end
if (count_boundary == 0) boundary_nodes = 0 ; end
if (count_semiboundary == 0) semiboundary_nodes = 0 ; end
if (count_transition == 0) transition_nodes = 0 ; end
63
count_boundaryelement = 0;
for k = 1:elemnum
if (any(num_of_neighbors(nonzeros((node(k,:)))) < 6))
count_boundaryelement = count_boundaryelement + 1;
boundary_elements(count_boundaryelement) = k;
end
end
%------------------------------------------------------------% Calculate centroids of all the elements and store them as
% poly_nodes. These centroids will be nodes in the new poly% -gonal mesh:
%------------------------------------------------------------cg
= zeros(elemnum,2);
poly_x = zeros(elemnum,2);
for k = 1:elemnum
cg (k,1) = (x(node(k,1),1) + x(node(k,2),1) + x(node(k,3),1))/3.0;
cg (k,2) = (x(node(k,1),2) + x(node(k,2),2) + x(node(k,3),2))/3.0;
poly_x (k,:) = cg (k,:);
end
%------------------------------------------------------------------% Construct hexagonal mesh using the interior nodes which are
% now stored in intereior_nodes array.
%
% split_flag will be used to check and eliminate which have been
% already been split.
% (if split_flag = 3, the elemnt is completely split)
%-------------------------------------------------------------------
64
for k = 1:count_interior
j=0;
for kk = 1:elemnum
if (node(kk,1) == interior_nodes(k) || node(kk,2) == ...
interior_nodes(k) || node(kk,3) == interior_nodes(k))
j = j + 1;
H6_node (k,j) = kk;
end
if (j == 6)
break
end
end
% Rearrange nodes in CCW direction:
%---------------------------------%Step 1: Find the mean:
x1 = poly_x(H6_node(k,:),1);
y1 = poly_x(H6_node(k,:),2);
cx = mean(x1);
cy = mean(y1);
%Step 2: Find the angles:
a = atan2(y1 - cy, x1 - cx);
%Step 3: Find the correct sorted order:
[~, order] = sort(a,'ascend');
%Step 4: Reorder the coordinates:
temp = zeros(6,1);
for ii=1:6
temp(ii) = H6_node(k,order(ii));
end
H6_node(k,:) = temp(:);
65
end
H6_count = count_interior;
%------------------------------------------------------------------% Construct pentagonal mesh using the boundary nodes which are
% now stored in boundary_nodes array.
%
% split_flag will be used to check and eliminate which have been
% already been split.
% (if split_flag > 3, the elemnt is completely split)
%------------------------------------------------------------------elem_flag = zeros(elemnum,1);
flag_count = 0;
for k = 1:count_boundary
j=0;
for kk = 1:elemnum
if (node(kk,1) == boundary_nodes(k) || node(kk,2) == ...
boundary_nodes(k) || node(kk,3) == boundary_nodes(k))
j = j + 1;
P5_node (k,j) = kk;
for jj=1:3
if (node(kk,jj) ~= boundary_nodes(k))
if (any(boundary_nodes == node(kk,jj)) || ...
any(semiboundary_nodes == node(kk,jj)) || ...
any(transition_nodes == node(kk,jj)))
j = j + 1;
if (elem_flag(kk)>0)
P5_node (k,j) = elem_flag(kk);
else
flag_count = flag_count + 1;
66
elem_flag(kk) = elemnum + flag_count;
tempx = zeros(1,2);
tempx(1,1) = (x(boundary_nodes(k),1) + x(node(kk,jj),1))/2.0;
tempx(1,2) = (x(boundary_nodes(k),2) + x(node(kk,jj),2))/2.0;
poly_x (elemnum + flag_count,:) = tempx(:);
P5_node (k,j) = elemnum + flag_count;
end
end
end
end
if (j == 5)
break
end
end
end
end
%------------------------------------------------------------------% Construct pentagonal mesh using the boundary nodes which are
% adjacent to corner, now stored in semiboundary_nodes array.
%
% split_flag will be used to check and eliminate which have been
% already been split.
% (if split_flag > 3, the elemnt is completely split)
%------------------------------------------------------------------Q4_count = 0;
Q4_flag = 0;
for k = 1:count_semiboundary
j=0;
for kk = 1:elemnum
if (any(node(kk,:) == semiboundary_nodes(k)))
67
j = j + 1;
P5_node (k + count_boundary,j) = kk;
for jj=1:3
if (node(kk,jj) ~= semiboundary_nodes(k))
if ((any(corner_nodes == node(kk,jj))) || ...
(any(boundary_nodes == node(kk,jj))))
j = j + 1;
if ((elem_flag(kk)>0) && ~ismember(2,(num_of_neighbors(node(kk,:)))))
P5_node (k + count_boundary,j) = elem_flag(kk);
else
%--------------------------------------------------% Construct Q4 element at corner in case the element
% has 2 neighbors
%--------------------------------------------------if ((elem_flag(kk)>0) && ismember(2,(num_of_neighbors(node(kk,:)))))
Q4_count = Q4_count + 1;
flag_count = flag_count + 1;
Q4_node(Q4_count, 1) = elem_flag(kk);
Q4_node(Q4_count, 2) = kk;
poly_x (elemnum + flag_count,:) = x(node(kk,jj),:);
Q4_node(Q4_count, 3) = elemnum + flag_count;
Q4_flag = 1;
end
%--------------------------------------------------flag_count = flag_count + 1;
elem_flag(kk) = elemnum + flag_count;
tempx = zeros(1,2);
68
tempx(1,1) = (x(semiboundary_nodes(k),1) + x(node(kk,jj),1))/2.0;
tempx(1,2) = (x(semiboundary_nodes(k),2) + x(node(kk,jj),2))/2.0;
poly_x (elemnum + flag_count,:) = tempx(:);
P5_node (k + count_boundary,j) = elemnum + flag_count;
%--------------------------------------------------% Construct Q4 element at corner in case the element
% has 2 neighbors
%--------------------------------------------------if ((Q4_flag == 1) && ismember(2,(num_of_neighbors(node(kk,:)))))
Q4_node(Q4_count, 4) = elemnum + flag_count;
Q4_flag = 0;
end
%--------------------------------------------------end
end
end
end
if (j == 5)
break
end
end
end
end
%------------------------------------------------------------------% Construct P5 elemets mesh using the corner nodes which are now
% stored in corner_nodes array.
%-------------------------------------------------------------------
connected_elem = zeros(2,1);
iii = 0;
for k = 1:count_corner
69
if (num_of_neighbors(corner_nodes(k)) == 3)
ii = 0;
iii = iii + 1;
for kk = 1:elemnum
if (any(node(kk,:)== corner_nodes(k)))
ii = ii + 1;
connected_elem(ii) = kk;
if(ii == 2)
break;
end
end
end
P5_node(count_boundary + count_semiboundary + iii,1) = connected_elem(1);
P5_node(count_boundary + count_semiboundary + iii,2) = elem_flag(connected_elem(1));
P5_node(count_boundary + count_semiboundary + iii,3) = connected_elem(2);
P5_node(count_boundary + count_semiboundary + iii,4) = elem_flag(connected_elem(2));
flag_count = flag_count + 1;
poly_x(elemnum + flag_count,:) = x(corner_nodes(k),:);
P5_node(count_boundary + count_semiboundary + iii,5) = elemnum + flag_count;
end
end
%---------------------------------------------------------------------% Construct two H6 elemets mesh using the transition nodes which are now
% stored in transition_nodes array.
%---------------------------------------------------------------------if (count_transition>0)
for k = 1:count_transition
ii = 0;
H6_count = H6_count + 1;
70
for kk = 1:elemnum
if (any(node(kk,:)== transition_nodes(k)))
ii = ii + 1;
H6_node(H6_count, ii) = kk;
if (any(ismember((node(kk,:)), boundary_nodes)))
ii = ii + 1;
H6_node(H6_count, ii) = elem_flag(kk);
end
end
%
if(ii == 6)
%
break;
%
end
end
end
end
%------------------------------------------------------------------% Rearrange nodes in CCW direction
%------------------------------------------------------------------if(Q4_count)
for k = 1:size(Q4_node,1)
%Step 1: Find the mean:
x1 = poly_x(Q4_node(k,:),1);
y1 = poly_x(Q4_node(k,:),2);
cx = mean(x1);
cy = mean(y1);
%Step 2: Find the angles:
a = atan2(y1 - cy, x1 - cx);
%Step 3: Find the correct sorted order:
[~, order] = sort(a,'ascend');
71
%Step 4: Reorder the coordinates:
temp = zeros(1,4);
for ii=1:4
temp(ii) = Q4_node(k,order(ii));
end
Q4_node(k,:) = temp(:);
end
end
for k = 1:size(P5_node,1)
%Step 1: Find the mean:
x1 = poly_x(P5_node(k,:),1);
y1 = poly_x(P5_node(k,:),2);
cx = mean(x1);
cy = mean(y1);
%Step 2: Find the angles:
a = atan2(y1 - cy, x1 - cx);
%Step 3: Find the correct sorted order:
[~, order] = sort(a,'ascend');
%Step 4: Reorder the coordinates:
temp = zeros(1,5);
for ii=1:5
temp(ii) = P5_node(k,order(ii));
end
P5_node(k,:) = temp(:);
end
for k = 1:size(H6_node,1)
%Step 1: Find the mean:
x1 = poly_x(H6_node(k,:),1);
y1 = poly_x(H6_node(k,:),2);
cx = mean(x1);
cy = mean(y1);
72
%Step 2: Find the angles:
a = atan2(y1 - cy, x1 - cx);
%Step 3: Find the correct sorted order:
[~, order] = sort(a,'ascend');
%Step 4: Reorder the coordinates:
temp = zeros(1,6);
for ii=1:6
temp(ii) = H6_node(k,order(ii));
end
H6_node(k,:) = temp(:);
end
P5_node(:,6) = NaN;
if(Q4_count) Q4_node(:,5) = NaN;Q4_node(:,6) = NaN; end
if(Q4_count) poly_node = flipud(vertcat(H6_node,P5_node,Q4_node)); else
poly_node = flipud(vertcat(H6_node,P5_node
)); end
%-------------------------------------------------------------------------% Uncomment to insert crack
[poly_x, poly_node, H6_node, P5_node,Q4_node] = InsertHorCrack...
( poly_node,poly_x );
%-------------------------------------------------------------------------if(Q4_count) Q4_count = size(Q4_node,1); end
P5_count = size(P5_node,1);
H6_count = size(H6_node,1);
%--------------%Plot the mesh:
%--------------figure (1)
patch('Faces',poly_node,'Vertices', poly_x,'FaceColor','w','FaceAlpha',0);
hold on
grid on
grid minor
73
GridColor='r';
set(gca, 'XColor', 'k','LineWidth',1.0)
set(gca, 'YColor', 'k','LineWidth',1.0)
hold off
%*******************%*******************%*******************%**************
%*******************%*******************%*******************%**************
%*******************
% Write Input File:
%*******************
%Get material properties:
%-----------------------Young = input('Enter Young''s modulus\n');
Poisson = input('Enter Poisson''s ratio\n');
clc;
%Write File header and material properties:
%-----------------------------------------t = date;
fprintf (output_fid, '%-40s\t %10s\n','Polygonal Element Problem',t);
fprintf (output_fid, '%-12s\n','Plane Stress');
fprintf (output_fid, '%-6i\t %-6i\t %6i\t %6i\t %6i\t %20s\n',H6_count+P5_count+Q4_count,
0,Q4_count,P5_count,H6_count,...
'!Number of Total, T3, Q4, P5, H6 Elements');
fprintf (output_fid, '%-6i\t
\t\t\t\t %20s\n',length(poly_x), '!Number of Nodes');
fprintf (output_fid, '%-6f\t %6f\t\t %20s\n',Young , Poisson, '!Youngs Modulus and Poisson
Ration');
frewind(input_fid);
%Write node coordinates and connectivity:
%---------------------------------------fprintf (output_fid,'%s\n', '#Nodes:');
for i = 1:length(poly_x)
fprintf (output_fid,'%6i\t %10f\t %10f\n', i,poly_x(i,1),poly_x(i,2));
end
74
fprintf (output_fid,'%s\n', '#Elements');
for i = 1:length(poly_node)
fprintf (output_fid,'%6i\t %6i\t %6i\t %6i\t %6i\t %6i\t %6i\t\n',i, ...
poly_node(i,1),poly_node(i,2), ...
poly_node(i,3),poly_node(i,4), ...
poly_node(i,5),poly_node(i,6));
end
%----------------------%Find nodes to constrain:
%----------------------x_constrain = input('Enter X-coordinate to be symmetrically constrained\n');
y_constrain = input('Enter Y-coordinate to be symmetrically constrained\n');
encastre_x = input('Enter X coordinate to be completely constrained\n');
encastre_y = input('Enter Y coordinate to be completely constrained\n');
[ xconstrain_node, yconstrain_node, encastre_node ] = Apply_Constrains...
( poly_x, x_constrain, y_constrain, encastre_x,encastre_y);
clc;
%----------------------%Calculate nodal forces:
%----------------------choice = input('Enter 1 to continue, 2 to apply uniform load on right,3 to apply uniform load on
top\n');
if (choice == 1)
force_nodex = 0; force_nodey = 0;
%Set force node to Null value
elseif(choice == 2)
BC_dim = input('Enter xoordinate where right force is applied\n');
magnitude = input('Enter force magnitude\n');
countx=0;
[ force_nodex, force_vectorx ] = Apply_UniformLoadsX( poly_x, BC_dim, magnitude);
75
force_nodey = 0;
clc;
elseif(choice == 3)
BC_dim = input('Enter ycoordinate where top force is applied\n');
magnitude = input('Enter force magnitude\n');
county=0;
[ force_nodey, force_vectory ] = Apply_UniformLoadsY( poly_x, BC_dim, magnitude);
force_nodex = 0;
clc;
end
%---------------------------%Write Boundary Conditions:
%---------------------------fprintf (output_fid,'%s\n', '#Boundary Conditions');
zeroval = '0.d0';
for i=1:size(poly_x,1)
% If node is part of force_node, apply the force
if(find(force_nodex == i))
fprintf (output_fid,'%6i\t %6i\t %10f\t %6i\t %10f\n', ...
i,2,force_vectorx(find(force_nodex == i),1), ...
2,force_vectorx(find(force_nodex == i),2));
elseif(find(force_nodey == i))
fprintf (output_fid,'%6i\t %6i\t %10f\t %6i\t %10f\n', ...
i,2,force_vectory(find(force_nodey == i),1), ...
2,force_vectory(find(force_nodey == i),2));
% If node is part of constrain_vector, apply Displacement BC
elseif (any(xconstrain_node == i))
fprintf (output_fid,'%6i\t %6i\t %10s\t %6i\t %10s\n', ...
i,1,zeroval,2,zeroval);
elseif (any(yconstrain_node == i))
fprintf (output_fid,'%6i\t %6i\t %10s\t %6i\t %10s\n', ...
i,2,zeroval,1,zeroval);
76
elseif (any(encastre_node == i))
fprintf (output_fid,'%6i\t %6i\t %10s\t %6i\t %10s\n', ...
i,1,zeroval,1,zeroval);
% Else tractionless BC
else
fprintf (output_fid,'%6i\t %6i\t %10s\t %6i\t %10s\n', ...
i,2,zeroval,2,zeroval);
end
end
fprintf (output_fid,'%s\n', '#End of file.');
fclose (input_fid);
fclose (output_fid);
clc;
7.2 Mesh Modification to Insert a Crack
function [poly_x, poly_node,H6_node, P5_node,Q4_node] = InsertHorCrack...
( poly_node, poly_x )
%-----------------------------------------------------------------%Function inserts horizontal crack in the mesh created in the main
%polygonal mesh created by meshing algorithm:
%-----------------------------------------------------------------Crack_y = input('Enter Y coordinate where crack will be inserted\n');
tip1 = input('Enter x coordinate of tip on Left\n');
tip2 = input('Enter x coordinate of tip on Right\n');
count = 0;
Crackcount = 0;
for i = 1:length(poly_node)
upflip=0;
downflip = 0;
%Deepending on the Y-coordinate position of all the element nodes
%determine if the elements can be present around element
%------------------------------------------------------------------for j =1:6
77
if(~isnan(poly_node(i,j)))
if ((poly_x((poly_node(i,j)),2)-Crack_y)>0)
upflip = 1;
else
downflip = 1;
end
end
end
if ((upflip)&&(downflip))
count = count +1;
FirstSet(count) = i;
end
end
CrackedSet = FirstSet;
%Arrage elements from left to right:
%----------------------------------for i = 1:count
x_min(i) = poly_x(poly_node(FirstSet(i),1),1);
for j =1:6
if(~isnan(poly_node(i,j)))
if (poly_x(poly_node(FirstSet(i),j),1)<x_min(i))
x_min(i) = poly_x(poly_node(FirstSet(i),j),1);
end
end
end
end
[~,ind] = sort(x_min);
FirstSet = FirstSet(ind);
%Split H6 elements from left to right:
%------------------------------------poly_length = length(poly_x(:,1));
j = 0;
crackflip = 0;
for i = 1:count
if(~isnan(poly_node(FirstSet(i),6)))
j = j + 1;
temp_elem = poly_node(FirstSet(i),:);
[~,indy] = sort(poly_x((temp_elem),2),'descend');
indx(1) = indy(1)+1; indx(2) = indy(1)+2;
indx(3) = indy(1)-1; indx(4) = indy(1)-2;
if(indx(1)>6)
if(indx(2)>6)
if(indx(3)<1)
if(indx(4)<1)
indx(1)
indx(2)
indx(3)
indx(4)
=
=
=
=
indx(1)-6;
indx(2)-6;
indx(3)+6;
indx(4)+6;
end
end
end
end
78
side_x = [poly_x(temp_elem(indx(1)),1), poly_x(temp_elem(indx(2)),1),...
poly_x(temp_elem(indx(3)),1), poly_x(temp_elem(indx(4)),1)]' ;
if (j==1)
new_node(j,1,1) = (side_x(1)+side_x(2))*0.5;
new_node(j,1,2) = Crack_y;
poly_length = poly_length+1;
bordernode1 = poly_length;% This node will be used to split border pentagon as well
poly_x(poly_length,1) = new_node(j,1,1);
poly_x(poly_length,2) = new_node(j,1,2);
else
new_node(j,1,1) = new_node(j-1,2,1);
new_node(j,1,2) = Crack_y;
end
new_node(j,2,1) = (side_x(3)+side_x(4))*0.5;
new_node(j,2,2) = Crack_y;
poly_length = poly_length+1;
bordernode2 = poly_length;% This node will be used to split border pentagon as well
poly_x(poly_length,:) = new_node(j,2,:);
%Create duplicated nodes at crack surface
if ((new_node(j,1,1)>tip1) && (new_node(j,1,1)<tip2) &&...
(new_node(j,2,1)>tip1) && (new_node(j,2,1)<tip2))
split_P5(2*(j-1)+1,:) = [poly_length, temp_elem(indy(1)) temp_elem(indy(2))
temp_elem(indy(3)) poly_length-1-crackflip];
if (crackflip)
new_node(j,3,:) = new_node(j-1,3,:);
else
new_node(j,3,:) = new_node(j,1,:);
crackflip=1;
end
new_node(j,4,:) = new_node(j,2,:);
poly_length = poly_length+1;
poly_x(poly_length,:) = new_node(j,4,:);
split_P5(2*(j-1)+2,:) = [poly_length, temp_elem(indy(4)) temp_elem(indy(5))
temp_elem(indy(6)) poly_length-2];
crackflip = 1;
else
split_P5(2*(j-1)+1,:) = [poly_length, temp_elem(indy(1)) temp_elem(indy(2))
temp_elem(indy(3)) poly_length-1-crackflip];
split_P5(2*(j-1)+2,:) = [poly_length, temp_elem(indy(4)) temp_elem(indy(5))
temp_elem(indy(6)) poly_length-1];
79
crackflip = 0;
end
end
end
%Split P5 elements from on borders:
%--------------------------------%Left Boundary
temp_elem = poly_node(FirstSet(1),1:5);
[~,indx] = sort(poly_x((temp_elem),1),'descend');
if ((poly_x(temp_elem(indx(1)),2))<Crack_y)
side_x(1) = indx(1)-1 ;side_x(2) =
side_x(3) = indx(1)-3 ;side_x(4) =
if(side_x(1)<1) side_x(1)
if(side_x(2)<1) side_x(2)
if(side_x(3)<1) side_x(3)
if(side_x(4)<1) side_x(4)
end
indx(1)-2 ;
indx(1)-4 ;
= side_x(1)+5;
= side_x(2)+5;
= side_x(3)+5;
= side_x(4)+5;
end
end
end
end
if ((poly_x(temp_elem(indx(1)),2))>Crack_y)
side_x(1) = indx(1)+1 ;side_x(2) =
side_x(3) = indx(1)+3 ;side_x(4) =
if(side_x(1)>5) side_x(1)
if(side_x(2)>5) side_x(2)
if(side_x(3)>5) side_x(3)
if(side_x(4)>5) side_x(4)
end
indx(1)+2 ;
indx(1)+4 ;
= side_x(1)-5;
= side_x(2)-5;
= side_x(3)-5;
= side_x(4)-5;
end
end
end
end
poly_length = poly_length+1;
temp_node(1) = (poly_x(temp_elem(side_x(2)),1)+poly_x(temp_elem(side_x(3)),1))*0.5;
temp_node(2) = Crack_y;
poly_x = [poly_x;temp_node];
new_elem = [bordernode1, poly_length, temp_elem(indx(1)), temp_elem(side_x(1)),
temp_elem(side_x(2))];
split_P5 = [split_P5;new_elem];
new_elem = [bordernode1,poly_length, temp_elem(side_x(3)), temp_elem(side_x(4))];
split_Q4 = new_elem;
%Right Boundary
temp_elem = poly_node(FirstSet(end),1:5);
[~,indx] = sort(poly_x((temp_elem),1),'ascend');
if ((poly_x(temp_elem(indx(1)),2))<Crack_y)
side_x(1) = indx(1)-1 ;side_x(2) = indx(1)-2 ;
side_x(3) = indx(1)-3 ;side_x(4) = indx(1)-4 ;
if(side_x(1)<1) side_x(1) = side_x(1)+5; end
80
if(side_x(2)<1) side_x(2) = side_x(2)+5; end
if(side_x(3)<1) side_x(3) = side_x(3)+5; end
if(side_x(4)<1) side_x(4) = side_x(4)+5; end
end
if ((poly_x(temp_elem(indx(1)),2))>Crack_y)
side_x(1) = indx(1)+1 ;side_x(2) = indx(1)+2 ;
side_x(3) = indx(1)+3 ;side_x(4) = indx(1)+4 ;
if(side_x(1)>5) side_x(1) = side_x(1)-5;
if(side_x(2)>5) side_x(2) = side_x(2)-5;
if(side_x(3)>5) side_x(3) = side_x(3)-5;
if(side_x(4)>5) side_x(4) = side_x(4)-5;
end
end
end
end
end
poly_length = poly_length+1;
temp_node(1) = (poly_x(temp_elem(side_x(2)),1)+poly_x(temp_elem(side_x(3)),1))*0.5;
temp_node(2) = Crack_y;
poly_x = [poly_x;temp_node];
new_elem = [bordernode2, poly_length, temp_elem(indx(1)), temp_elem(side_x(3)),
temp_elem(side_x(4))];
split_P5 = [split_P5;new_elem];
new_elem = [bordernode2,poly_length, temp_elem(side_x(1)), temp_elem(side_x(2))];
split_Q4 = [split_Q4;new_elem];
%Arrange nodes in CCW direction:
%--------------------------------for k = 1:size(split_P5,1)
%Step 1: Find the mean:
x1 = poly_x(split_P5(k,:),1);
y1 = poly_x(split_P5(k,:),2);
cx = mean(x1);
cy = mean(y1);
%Step 2: Find the angles:
a = atan2(y1 - cy, x1 - cx);
%Step 3: Find the correct sorted order:
[~, order] = sort(a,'ascend');
%Step 4: Reorder the coordinates:
temp = zeros(1,5);
for ii=1:5
temp(ii) = split_P5(k,order(ii));
end
split_P5(k,:) = temp(:);
end
for k = 1:size(split_Q4,1)
%Step 1: Find the mean:
x1 = poly_x(split_Q4(k,:),1);
81
y1 = poly_x(split_Q4(k,:),2);
cx = mean(x1);
cy = mean(y1);
%Step 2: Find the angles:
a = atan2(y1 - cy, x1 - cx);
%Step 3: Find the correct sorted order:
[~, order] = sort(a,'ascend');
%Step 4: Reorder the coordinates:
temp = zeros(1,4);
for ii=1:4
temp(ii) = split_Q4(k,order(ii));
end
split_Q4(k,:) = temp(:);
end
figure(2)
patch('Faces',split_P5,'Vertices', poly_x,'FaceColor','w','FaceAlpha',0);
patch('Faces',split_Q4,'Vertices', poly_x,'FaceColor','w','FaceAlpha',0);
poly_node(FirstSet,:)=[];
H6_node = [];
P5_node = [];
Q4_node = [];
temp_H6 = 0;
temp_P5 = 0;
temp_Q4 = 0;
for i = 1:size(poly_node,1)
if(~isnan(poly_node(i,5)) && ~isnan(poly_node(i,6)))
temp_H6 = temp_H6 + 1;
H6_node(temp_H6,:) = poly_node(i,:);
elseif (~isnan(poly_node(i,5)) && isnan(poly_node(i,6)))
temp_P5 = temp_P5 + 1;
P5_node(temp_P5,:) = poly_node(i,:);
elseif (isnan(poly_node(i,5)))
temp_Q4 = temp_Q4 + 1;
Q4_node(temp_Q4,:) = poly_node(i,:);
end
end
split_P5(:,6) = NaN;
split_Q4(:,5) = NaN;split_Q4(:,6) = NaN;
P5_node = [P5_node; split_P5];
Q4_node = [Q4_node; split_Q4];
poly_node = flipud(vertcat(H6_node,P5_node,Q4_node));
clc;
end
82
8 Bibliography
[1]
J. R. Lund and J. P. Byrne, “Leonardo da Vinci’s tensile strength tests: implications for the
discovery of engineering mechanics,” Civil. Eng. Env. Syst, vol. 0, pp. 1–8.
[2]
J. J. Duga, W. H. Fisher, R. W. Buxbaum, A. R. Rosenfield, A. R. Buhr, E. J. Honton, and
S. C. McMillan, “The Economic Effects of Fracture in the United States - Richard Palmer
Reed - Google Books,” National Bureau of Standards, 1983. .
[3]
X. Xing-hua and S. Bao-yu, “A review of fracture rock hydraulic fracturing research,” Rock
and Soil Mechanics, 2004. .
[4]
M. J. Turner, “Stiffness and Deflection Analysis of Complex Structures,” J. Aeronaut. Sci.,
vol. 23, no. 9, pp. 805–823, Sep. 1956.
[5]
A. R. Ingraffea, Computational Fracture Mechanics, no. 2002. 2007.
[6]
G. Liu and D. Karamanlidis, “Mesh Free Methods: Moving Beyond the Finite Element
Method,” Appl. Mech. Rev., vol. 56, no. 2, p. B17, 2003.
[7]
Y. J. Liu, Y. X. Li, and W. Xie, “Modeling of multiple crack propagation in 2-D elastic
solids by the fast multipole boundary element method,” Eng. Fract. Mech., vol. 172, pp. 1–
16, 2017.
[8]
M. J. Berger and P. Colella, “Local Adaptive Mesh Refinement for Shock Hydrodynamics,”
J. Comput. Phys., vol. 82, no. 6484, 1989.
[9]
A. R. Ingraffea, Ingraffea, and A. R., “Computational Fracture Mechanics,” in Encyclopedia
of Computational Mechanics, Chichester, UK: John Wiley & Sons, Ltd, 2007.
[10] D. Krajcinovic, “Continuous Damage Mechanics Revisited: Basic Concepts and
83
Definitions,” J. Appl. Mech., vol. 52, no. 4, p. 829, Dec. 1985.
[11] M. J. Borden, C. V Verhoosel, M. A. Scott, T. J. R. Hughes, and C. M. Landis, “A phasefield description of dynamic brittle fracture,” 2012.
[12] T. Belytschko, R. Gracie, and G. Ventura, “A review of extended/generalized finite element
methods for material modeling,” Model. Simul. Mater. Sci. Eng., vol. 17, no. 4, p. 43001,
Jun. 2009.
[13] T. Belytschko and T. Black, “Elastic crack growth in finite elements,” vol. 620, no. July
1998, pp. 601–620, 1999.
[14] D. S. Dugdale, “Yielding of steel sheets containing slits,” J. Mech. Phys. Solids, vol. 8, no.
2, pp. 100–104, 1960.
[15] C. Song and J. P. Wolf, “The scaled boundary finite-element method—alias consistent
infinitesimal finite-element cell method—for elastodynamics,” Comput. Methods Appl.
Mech. Eng., vol. 147, no. 3–4, pp. 329–355, Aug. 1997.
[16] E. L. Wachspress, “A rational basis for function approximation,” Lect. Notes Math., 1971.
[17] G. Manzini, A. Russo, and N. Sukumar, “New perspectives on polygonal and polyhedral
finite element methods,” Math. Model. Methods Appl. Sci., vol. 24, no. 8, pp. 1–35, 2014.
[18] M. S. Floater, “Mean value coordinates,” Comput. Aided Geom. Des., vol. 20, no. 1, pp. 19–
27, 2003.
[19] R. Sibson, “A vector identity for the Dirichlet tessellation,” Math. Proc. Cambridge Philos.
Soc., vol. 87, no. 1, p. 151, 1980.
[20] H. Hiyoshi and K. Sugihara, “Two generalizations of an interpolant based on voronoi
84
diagrams,” Int. J. Shape Model., vol. 5, no. 2, pp. 219–231, Dec. 1999.
[21] S. Ghosh, K. Lee, and S. Moorthy, “Multiple scale analysis of heterogeneous elastic
structures using homogenization theory and voronoi cell finite element method,” Int. J.
Solids Struct., vol. 32, no. 1, pp. 27–62, Jan. 1995.
[22] G. Dasgupta, “Interpolants within convex polygons: Wachspress’ Shape Functions,” ASCE
- J. Aerosp. Eng., vol. 16, no. 1, pp. 1–8, 2003.
[23] R. Courant, “Variational Methods for the Solution of Problems of Equilibrium and
Vibrations,” Bull. Am. Math. Soc., vol. 49, no. 1, pp. 1–24, 1943.
[24] I. Taig, Structural analysis by the matrix displacement method. Warton: English Electric
Aviation Limited, 1962.
[25] M. de Berg, M. van Kreveld, M. Overmars, and O. C. Schwarzkopf, Computational
Geometry. Berlin, Heidelberg: Springer Berlin Heidelberg, 2000.
[26] J. Warren, “Barycentric Coordinates for Convex Polytopes,” vol. 6, no. July, pp. 1–14,
1996.
[27] M. S. Floater, G. Ko`s, and M. Reimers, “Mean value coordinates in 3D,” Comput. Aided
Geom. Des., vol. 22, no. 7 SPEC. ISS., pp. 623–631, 2005.
[28] M. Meyer, A. Barr, H. Lee, and M. Desbrun, “Generalized Barycentric Coordinates on
Irregular Polygons,” J. Graph. Tools, vol. 7, no. 1, pp. 13–22, 2002.
[29] N. Sukumar and a. Tabarraei, “Conforming polygonal finite elements,” Int. J. Numer.
Methods Eng., vol. 61, no. 12, pp. 2045–2066, 2004.
[30] D. A. Dunavant, “High Degree Efficient Symmetrical Gaussian Quadrature Rules For the
85
Triangles,” Int. J. Numer. Methods Eng., vol. 21, no. April 1984, 1985.
[31] C. Talischi, G. H. Paulino, A. Pereira, and I. F. M. Menezes, “PolyMesher: A generalpurpose mesh generator for polygonal elements written in Matlab,” Struct. Multidiscip.
Optim., vol. 45, no. 3, pp. 309–328, 2012.
[32] J. H. Michell, “On the Direct Determination of Stress in an Elastic Solid, with application
to the Theory of Plates,” Proc. London Math. Soc., vol. s1-31, no. 1, pp. 100–124, Apr.
1899.
[33] R. L. Taylor, J. C. Simo, O. C. Zienkiewicz, and A. C. H. Chan, “The patch test—a condition
for assessing FEM convergence,” Int. J. Numer. Methods Eng., vol. 22, no. 1, pp. 39–62,
Jan. 1986.
[34] C. Talischi and G. H. Paulino, “Addressing integration error for polygonal finite elements
through polynomial projections: A patch test connection,” Math. Model. Methods Appl. Sci.,
vol. 24, no. 8, pp. 1701–1727, Jul. 2014.
[35] S. Timoshenko, Theory of elasticity, by S. Timoshenko and J.N. Goodier, ... 2nd edition.
New York-Toronto-London: McGraw-Hill Book Co., 1951.
[36] C. E. Augarde and A. J. Deeks, “The use of Timoshenko’s exact solution for a cantilever
beam in adaptive analysis,” Finite Elem. Anal. Des., vol. 44, pp. 595–601, 2008.
[37] A. R. Khoei, R. Yasbolaghi, and S. O. R. Biabanaki, “A polygonal finite element method
for modeling crack propagation with minimum remeshing,” Int. J. Fract., vol. 194, no. 2,
pp. 123–148, 2015.
[38] T. L. (Ted L. . Anderson, Fracture mechanics : fundamentals and applications. Taylor &
Francis, 2005.
86
[39] Westergaard H.M., “Bearing Pressures and Cracks,” J. Appl. Mech., vol. 6, pp. 49–53, 1939.
[40] G. R. Irwin, “Analysis of Stresses and Strains near the End of a Crack Traversing a Plate,”
J. Appl. Mech., vol. 24, pp. 361–364, 1957.
[41] M. L. Williams, “The Bending Stress Distribution at the Base of a Stationary Crack,” J.
Appl. Mech., vol. 28, no. 1, p. 78, Mar. 1961.
[42] S. K. Chan, S. Tuba, W. K. Wilson, “On the finite element method in linear fracture
mechanics-l,” Eng. Froctwe Mech., vol. 2, 1970.
[43] M. Isida, “Effect of Width and Length on Stress Intensity Factors of Internally Cracked
Plates Under Various Boundary Conditions,” Int. J. Fract. Mech., vol. 7, no. 3, 1971.
[44] A. George, “Nested dissection of a regular finite element mesh,” SIAM J. Numer. ANAL,
vol. 10, no. 2, 1973.
87