implementing an iga compatible user-element for msc marc
TRANSCRIPT
Implementing an IGA compatible user-element for MSC Marc
Pieter J. BarendrechtEindhoven University of TechnologyOctober 7, 2012
Supervisorsdr. ir. Olaf van der Sluisdr. ir. Clemens V. Verhoosel
Abstract
IsoGeometric Analysis is a relatively new method that is currently receiving a lot of interestin the academic world, though the software companies developing popular design- andanalysis packages remain somewhat behind. It is therefore that we investigate to whatextent it is feasible to implement this new technique ourselves.
In order to appreciate this novel approach, the main principles of both Computer AidedGeometric Design and Finite Element Analysis are explained in a practical and intuitiveway. Eventually by combining the concepts of B-Splines, Bezier extraction and FiniteElement Analysis we establish a solid foundation on which we can base our implementation.Apart from a detailed overview of the Fortran user-element that is designed to work withMSC Marc, we take a look at some essential parts of the pre- and post processor developedin Matlab.
Ultimately by running simulations on a representative geometry, we can conclude thatit is very well possible to integrate this new technique into an existing software pack-age, although there are still some minor issues that prevent this integration from beingcompletely smooth.
Notation with regard to internal references
In order to navigate through this report more efficiently, the references in this report toequations and figures consist of two parts (following the example of [PR08] and [AS10]):
1. The standard or default part, denoting the relevant section and the number of theequation or figure
2. An additional part, consisting of the page number the equation or figure appears on.
The latter one is typeset as subscript, as to avoid any confusion. So for example,Figure (2.4)/5 refers to the 4th figure in section 2, and is shown on page 5.
i
Table of Contents
Abstract i
1 Introduction 11.1 Why IsoGeometric Analysis (IGA)? . . . . . . . . . . . . . . . . . . . . . . 11.2 Compatibility with Finite Element Analysis (FEA) . . . . . . . . . . . . . . 11.3 The purpose of this research . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2 IsoGeometric Analysis 32.1 Splines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1.1 Parametric curves . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32.1.2 B-Splines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Bezier extraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.2.1 The concept of blossoming . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 Finite Element Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.3.1 Approaching the solution of a differential equation . . . . . . . . . . 112.3.2 FEM and basis functions . . . . . . . . . . . . . . . . . . . . . . . . 122.3.3 The stiffness matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4 Splines and analysis: CAGD and FEA combined . . . . . . . . . . . . . . . 15
3 Implementation 173.1 Pre-processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.2 The user-element . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193.3 Post-processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4 Simulations 234.1 Plate with hole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5 Conclusions and remarks 27
Appendix 28
A Input file for MSC Marc 28
B The user-element for MSC Marc 30
C Interesting parts from the pre- and post-processor code 31
D Background on FEM related topics 35D.1 Inverse of a 2× 2 matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35D.2 Change of variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
References 37
ii
1 Introduction
This report is the result of an internship at Philips. For about four months, researchwas conducted on how to implement an IGA compatible user-element for the commercialsoftware package MSC Marc.
1.1 Why IsoGeometric Analysis (IGA)?
Nowadays, the solutions to (partial) differential equations to find the distribution of aquantity like temperature, displacement or stress in an object are almost exclusively com-puted (or rather approximated) with some numerical method. The Finite Element Method(FEM) is the most used approach, but even this method seems to have some shortcomings.Thinking about complex geometries with for instance circular segments, it is a difficultand time-consuming task to find a sufficing mesh (i.e. the collection of all elements) forsuch an object. Besides, such a mesh will nearly always be just an approximation of thegeometry, meaning that it is not exact (which is an issue for some cases).
At the same time, communication between the designers (CAGD) and the FEA peopleis not nearly as efficient as it should be. It should be noted that, although the similaritiesbetween CAGD and FEA are abundant, the different terminology used in these researchfields can be quite confusing†. These discrepancies and other misunderstandings naturallylead to inefficiencies in the design process.
These two issues are roughly the motivation that led to a new technique, IsoGeometricAnalysis [HCB05]. The main objective of IGA is therefore to unite the worlds of CAGDand FEA. This is done by using the same basis functions for both design and analysis, aswill be explained in more detail later on. The result of this technique should be a bettercollaboration between CAGD and FEA. Ultimately, from a computational perspectivethe benefits are more efficient meshes (less computation time required to find better, i.e.exact, meshes), and as it turns out, approximations with a higher continuity (which is aconsequence of the selected basis functions).
1.2 Compatibility with Finite Element Analysis (FEA)
Because this new technique has only been around since 2005, it is not yet supported bythe much used commercial software packages. A relevant question would be what kind ofsoftware would be required to make use of IGA. If a completely new design and analysisenvironment would need to be implemented, that would certainly not be very conducive.Fortunately, using the concept of Bezier extraction, it seems to be possible to combine IGAwith existing FEA software. However, this can only be the case if the software provides apossibility to implement custom elements, so called user-elements. It should therefore bepossible to get IGA to work alongside a flexible FEA software package.
†For instance, the concepts degree and order (w.r.t. polynomials) are interpreted as one and the samething in the FEA community, whereas in CAGD, the order is defined as the degree plus one. Anothernotable difference is that the FEA encampment talks about the partition of unity property when the basisfunctions add up to unity, whereas the CAGD community would say that the corresponding curve is anaffine combination of the control points. Finally, because FEA is so focused on the basis functions, thereseems to be the tendency to use the same name for both the basis functions and the actual curve (e.g.a B-Spline). CAGD is a little stricter in this distinction: B-Splines are the basis functions, the B-Splinecurve is the accompanying curve.
1
1.3 The purpose of this research
Looking at the number of citations of the pioneering paper [HCB05], and the book onIGA [CHB09] that was published in 2009, it is clear that there is an increasing interestin IsoGeometric Analysis. This, in turn, causes companies to be curious about such anew technique. In this case, there was a position for an internship at Philips to look intoexactly the mentioned research question: is it possible to implement an IGA compatibleuser-element for a FEA software package? Since (among others) the package MSC Mar-c/Mentat is used a lot at Philips, the purpose became to implement a user-element forMSC Marc, the computational part of the package. Because of the relatively short timespan, the objective became to write a really basic, fundamental element, which is by nomeans complete or generally applicable.
The rest of this report guides the reader through the necessary steps to come upwith the result, the user-element. Background information, along with some examples, isprovided where needed.
2
2 IsoGeometric Analysis
IsoGeometric Analysis uses the same basis functions for both design and analysis. In thecase of design, they are used to draw curves and surfaces. With analysis, they span thespace in which the approximation for the differential equation lies.
In this section, a brief overview of CAGD is given. After the introduction of Beziercurves and B-Splines, we look at Bezier extraction in some detail. Next, the concept ofFEA is described in a concise fashion, and extended to IGA.
2.1 Splines
Splines are the main concept of CAGD. Essentially, a spline curve is a piecewise polynomialcurve, where the segments are connected with a certain continuity†. Before we take a lookat these spline curves, let’s first take a look at the individual segments, simple parametriccurves.
This section only provides the most basic information on curves – for a lot more detailson CAGD, see for instance the excellent references [Sal06], [Gol03] and [Far02].
2.1.1 Parametric curves
A parametric curve is a curve that is defined using at least‡ two functions, x(t) and y(t).For a single value of t, these functions provide the x and y coordinates of a point on thecurve. Well known examples are the Lagrange curve and Bezier curve.
Characteristics of the Lagrange curve is that it interpolates the control points, andthat part of the curve can be outside of the control polygon, as can be seen in Figure(2.1a)/3. The Bezier curve does not have these properties – in general only the first andlast control points are interpolated, the other points pull the curve towards them – seeFigure (2.1b)/3. Moreover, the entire curve will always be within the control polygon (thedashed curve).
P0
P1
P0
(a)
P0
P1
P2
(b)
Figure 2.1: Lagrange and Bezier curves, using the same control points P0, P1 and P2.
The functions x(t) and y(t) obviously depend on the control points. Moreover, theydepend on the desired behavior of the curve, e.g. interpolating or approximating. Thebottom line is that both functions are the product of the control points (either the x or ycoordinate) and the basis functions:
∑ni=1 PiBi(t). Each control point has its own basis
function, that tells how much the curve is influenced by the control point.
†When two segments join in a single point, the connection is called C0 continuous. If the first derivativefor both segments is the same in this point, it’s called C1, mutatis mutandis for higher order continuities.
‡If it is a curve in 3D, another function z(t) is required to provide the coordinate for the z-axis.
3
The basis functions for a quadratic Lagrange curve (which requires three control points)are depicted in Figure (2.2a)/4, the basis functions for a quadratic Bezier curve in Figure(2.2b)/4. A very important property of both bases is that they add up to unity for everyvalue of t, as indicated in the figures. The consequence of this partition of unity propertyis not trivial – it boils down to the fact that the resulting curve is an affine combinationof the control points†. This in turn is essential for a curve to be used in CAGD – whenrelocating/moving the curve, it maintains its shape. This would not be the case when thebasis functions would not form a partition of unity!
-0.2
0
0.2
0.4
0.6
0.8
1
6/8
3/8
-1/8
8/8 = 1
+
(a)
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
9/16
6/16
1/16
16/16= 1
+
(b)
Figure 2.2: The Lagrange curve uses the Lagrange basis functions, the Bezier curve theBernstein polynomials. Both bases have the partition of unity property. The colors of thebasis functions correspond to the colors of the control points in Figure (2.1a)/3 and Figure(2.1b)/3.
A notable difference between the Lagrange and Bezier bases is that the latter is com-pletely non-negative, whereas the former is not. Therefore, from a numerical point of view,the Bezier basis (the Bernstein polynomials) is more stable: a Bezier curve is a convexcombination of the control points. This is one of the reasons why we choose to use Beziercurves.
It might be useful to look at a Bezier curve in more detail. Choosing the control pointsP0 = (1, 3), P1 = (5, 2) and P2 = (3, 4), and using the standard Bernstein basis Bi(t) ={(1− t)2, 2t(1− t), t2} with t ∈ [0, 1], the functions x(t) and y(t) become
x(t) =
n∑i=1
Pi,xBi(t) = 1 (1− t)2 + 5 2t(1− t) + 3 t2 = −6t2 + 8t+ 1
y(t) =n∑
i=1
Pi,yBi(t) = 3 (1− t)2 + 2 2t(1− t) + 4 t2 = 3t2 − 2t+ 3
The functions x(t), y(t) and the resulting Bezier curve are depicted in Figure (2.3)/5.When designing (complex) geometries, connecting individual curves is a natural ap-
proach. But it can be quite difficult to connect these curves, or segments, with a certaincontinuity. For instance, for the reflection of light (ray tracing), a C2 continuity is requiredfor a natural result, even though C1 connections might already look smooth enough. In-stead of figuring out how to position the control points of each individual segment, let’slook at a different basis which solves this exact problem: the B-Splines.
†For each value of t the control points are multiplied by some constants, and these constants sum tounity. So in fact, each point on the curve is an affine combination of the control points. Perhaps a moreintuitive explanation is that affine combinations are not dependent on the position of the origin.
4
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 11
1.5
2
2.5
3
3.5
4
t
x(t)
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 12.6
2.8
3
3.2
3.4
3.6
3.8
4
y(t)
t
P0
P1
P2
Figure 2.3: The functions x(t), y(t) and the resulting Bezier curve, using the control pointsP0 = (1, 3), P1 = (5, 2) and P2 = (3, 4).
2.1.2 B-Splines
Although a B-Spline curve and its basis, the B-Splines, might look completely differentfrom a Bezier curve and its basis, the Bernstein polynomials, there are a lot of similaritiesas well. The B-Splines are completely non-negative, and the curve stays within the convexhull†. See Figure (2.4)/5.
0 0.5 1 1.5 2 2.5 3 3.5 40
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
Figure 2.4: A cubic B-Spline curve and its accompanying cubic B-Spline basis functions.The colors of the control points correspond to the colors of the basis functions.
B-Splines can be defined in many ways, such as Divided Differences [BBB95], Con-volution [dB01], Projection [Pra84] (like Box Splines [BHR93]) and Blossoming [Man06].Of course they can also be derived manually (i.e. considering (degree-1) continuity andhence solving (degree-1) equations), see Salomon [Sal06]. An often used method to define
†The convex hull basically is the smallest convex set that contains all control points. For instance, theconvex hull of the Bezier curve in Figure (2.1b)/3 is the triangle spanned by the three control points.
5
B-Splines is the Cox-de Boor recurrence equation, using something called a knot vector,Ξ.
In contrast to quadratic (or higher degree) Bezier curves, where always the samequadratic (or higher degree) basis (Bernstein polynomials) is used, in case of B-Splines youcan choose the basis yourself. This is because the curve consists of multiple segments – wecan decide how (i.e. with which continuity) these segments should meet. The knot-vectorΞ consists of a group of non-decreasing numbers, where a repetition of a knot indicates adecrease in continuity for the corresponding joint (i.e. place where two segments meet).
For example, a different basis could be used for the 7 control points in Figure (2.4)/5 –
even a different degree! Using the knot-vector† indicated in Figure (2.5)/6, we now obtaina quadratic B-Spline basis. Notice the sharp basis function, caused by repetition of thenumber 4 in the knot-vector. In the corresponding joint, the two segments of a B-Splinecurve using this basis will join with reduced continuity, in this case C1−1 = C0.
Ξ = [0, 0, 0, 1, 2, 4, 4, 5, 5, 5]
Figure 2.5: B-Splines defined using the indicated knot-vector Ξ. The result is a quadraticbasis.
It is important to realize that a B-Spline curve is just a set of concatenated Beziercurves. Even better, these segments are in general connected to each other with thehighest possible continuity – for a quadratic B-Spline curve that means C1, for cubics C2,and so on. This solves our problem from the previous section. It also means that the samecurve can be represented in two different ways, as is depicted in Figure (2.6)/7. Noticethat the B-Spline curve requires less control points, which is a result of how a B-Splinecurve re-uses control points. A Bezier curve only re-uses the last point of the previoussegment, a B-Spline in general re-uses all points except for the first one. That meansthat each additional cubic Bezier curve requires three control points, whereas a B-Splineonly requires one additional point for each new cubic segment. For four segments, that isrespectively 4 + 1 + 1 + 1 = 7 and 4 + 3 + 3 + 3 = 13 points (the first cubic segment ofcourse requires four points in both cases).
Finally, it is also possible to draw rational curves with B-Spline curves: NURBS curves,which stands for Non-Uniform Rational B-Spline. The general idea is to assign a weightto each control point, which determines to what extent the NURBS curve is attracted toit. More information can be found in [Far99].
†The concept of a knot-vector should not be completely new, since Lagrange curves use somethingsimilar to define the basis functions. However, most of the time the uniform Lagrange basis functions areused – in this case, the knots are equidistant.
6
Figure 2.6: A B-Spline curve can be described as concatenated Bezier curves. Notice thedifferent number of control points (respectively 7 and 13).
2.2 Bezier extraction
From the knowledge that B-Spline curves can be described as concatenated Bezier curves,it follows that both expressions represent the same curve: P TN and P T N . The Bezier andB-Spline points are stored in respectively the column matrices P and P , the correspondingbasis functions in N and N .
Finding the individual Bezier curves from a B-Spline curve is called Bezier decompo-sition, or Bezier extraction [RS04, BSEH11, BCRV12].
When we realize that the control points for the Bezier curves, P , are actually convexcombinations of the control points of the B-Spline curve, P , it should not be surprisingthat we can write P = CTP with C some matrix which rows add up to unity (because ofthe convex combinations).
Next step is rewriting the equality P TN = P T N :
P TN = P T N ⇒ P = CTP ⇒ P T = P TC
⇒ P T N = P TCN = P TN ⇒ N = CN
So the B-Spline basis functions can be found by multiplying the Bezier basis functions(the Bernsteins) by the same matrix C. Since the rows of C (i.e. the columns of CT )generally do not add up to unity, the B-Spline basis functions are no affine combinationsof the Bernstein polynomials.
The only thing left is to find a suitable method to find the CT matrix. Althoughthere are multiple ways of doing this, the approach described in the next subsection isquite comprehensible without introducing too many new concepts (like knot insertion,knot refinement, and several other topics that are necessary to understand some othermethods).
2.2.1 The concept of blossoming
Blossoming is presumably the most intuitive method to explain Bezier extraction. Math-ematically spoken, a blossom [Ram87, Ram89, Sei93] is the polar form of a function f(t).
A blossom describes the same function, but in a different way. Say that we would liketo find the two blossoms† of a quadratic Bezier curve. Although Bezier curves are definedusing Bernstein basis functions, effectively each of the functions x(t) and y(t) is a functionof the basis [1, t, t2]. Notice that we use a single variable, t, and that its highest poweris two. The blossom describes the same function in multiple variables of only power one.Therefore, in this case, two variables are needed to describe the same function.
†In 2D, such a parametric curve requires two functions, x(t) and y(t), and in 3D a third one, z(t).Each function has its own blossom.
7
As indicated in a previous section, the two functions x(t) and y(t) for the Bezier curvedepicted in Figure (2.3)/5 are
x(t) = −6t2 + 8t+ 1
y(t) = 3t2 − 2t+ 3
Then the corresponding blossoms are [Gal99]:
x(u, v) = −6uv + 8(u+ v)
2+ 1 = −6uv + 4(u+ v) + 1 (2.1)
y(u, v) = 3uv − 2(u+ v)
2+ 3 = 3uv − (u+ v) + 3 (2.2)
Three important properties of a blossom are that it is symmetric, multi-affine, and thatit has the diagonal property. The first one (symmetry) means that it does not matterin which sequence we use the new variables u and v, i.e. f(u, v) = f(v, u). Second, themulti-affine property basically says that it is possible to linearly interpolate two points,but only if all but one variable are equal to each other. In the quadratic case that wouldmean that either u or v is the same for two points, for cubics – using variables u, v and w– either combination of two out of these three variables (e.g. u and v, u and w or v andw). The diagonal property is perhaps the most important. It says that when all variableshave the same value (i.e. u = v for quadratics, u = v = w for cubics), then f(u, v) (orf(u, v, w)) is a point on the original function. So actually, the blossom is a lot more thanonly the function itself.
When we plot the blossom from Equation (2.1)/8, we can easily check these threeproperties. See Figure (2.7a)/8 for this plot (which is not a curve but a surface, becausewe are now using variables u and v instead of just t).
uv
x(u,v)
0
0.2
0.4
0.6
0.8
1 0
0.2
0.4
0.6
0.8
10
2
4
6
(a)
u
v
0 0.2 0.4 0.6 0.8 10
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
(b)
Figure 2.7: Blossom x(u, v) of the function x(t) = −6t2 + 8t + 1. The multi-affine andsymmetry properties are clearly visible.
In this plot we can already observe two of the properties – the multi-affine property isobvious, because for each constant u or v, there is a line, formed by varying v or u in [0, 1].Second, the symmetry is visible, although it is better viewed from a top view, as can beseen in Figure (2.7b)/8. The diagonal property can be seen when the plot is rotated to
the right angle (i.e. 45 azimuth and 0 elevation), see Figure (2.8a)/9 – the diagonal† (here
†It is called the diagonal property because the line u = v is the main diagonal of the uv-plane. This
8
the underside) of the surface traces exactly the same curve as x(t), depicted in Figure(2.8b)/9.
x(u,v)
1
1.5
2
2.5
3
3.5
4
4.5
5
(a)
t
x(t)
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 11
1.5
2
2.5
3
3.5
4
4.5
5
(b)
Figure 2.8: When rotating the plot to (45, 0), the diagonal property becomes visible. Thediagonal (here the underside) of the surface traces exactly the same curve as the one onthe right, x(t).
Remember that a Bezier curve can be described as a B-Spline consisting of a singlesegment. The knot vector, if the standard Bernsteins (t ∈ [0, 1]) are chosen, would beΞ = [0, 0, 0, 1, 1, 1]. Omitting the first and last knot†, only [0, 0, 1, 1] is left. Repetitivelytaking two consecutive knots (and repeating the last one) results in the sequence [0, 0],[0, 1], [1, 1]. When these values are now substituted in x(u, v) and y(u, v), the result arethe Bezier control points [Man06]: P0 = (1, 3), P1 = (5, 2) and P2 = (3, 4)! We adopt theshorthand notation [u, v] which refers to the blossom in this point, f(u, v).
Finally, combining all these four properties, let’s take a look at an example. Again wepick an arbitrary quadratic Bezier curve, and place the two relevant knot values next toeach control point. See Figure (2.9)/9.
[0,0]
[0,1]=[1,0]
[1,1]
[0,0]
[0,1]=[1,0]
[1,1]
[0,½]
[1,½]
[0,0]
[0,1]=[1,0]
[1,1]
[0,½]
[1,½]
[½,½]
Figure 2.9: A simple blossoming example, using an arbitrary Bezier curve.
Because of the symmetry property, the label [0, 1] can be written as [1, 0]. Next, sincewe have the multi-affine property, we can interpolate between [0, 0] and [0, 1], and alsobetween [1, 0] and [1, 1]. Finally, due to the diagonal property, we can find the point on
concept can be extended to higher dimensions, although it is obviously not possible to plot these higherdimensional blossoms anymore.
†The values of the first and last knot are not relevant for the calculation of the basis functions, theyare just a byproduct of the Cox-de Boor equation.
9
the Bezier curve that corresponds to (for instance) t = 12 , simply by locating the label
[12 ,12 ]. Remind that [u, v] is a short notation for the blossom(s) f(u, v), in this case x(u, v)
and y(u, v). This, in turn, is accomplished by linearly interpolating the labels [0, 12 ] and[1, 12 ]. The result is in fact the famous de Casteljau algorithm [dC63, dC93].
With some effort, it can be shown that all these properties also hold for the blossomsof a general B-Spline curve. Since we know that, for instance, a quadratic B-Spline curvewith knot vector Ξ = [0, 0, 0, 2, 3, 6, 6, 6] consists of three individual Bezier curves, we candefine the labels that correspond to the control points of these Bezier curves:
1.) The first segment, from t = 0 to t = 2, resulting in the Bezier knot vector [0, 0, 0, 2, 2, 2]and reduced to [0, 0, 2, 2]. The accompanying labels are therefore [0, 0], [0, 2] and[2, 2].
2.) The second segment, from t = 2 to t = 3, has the labels [2, 2], [2, 3] and [3, 3].
3.) The third segment, from t = 3 to t = 6, has the labels [3, 3], [3, 6] and [6, 6].
Using the blossoming properties, we can now locate these labels, see Figure (2.10)/10.
[0,0]
[0,2]=[2,0]
[2,3]=[3,2]
[3,6]=[6,3]
[6,6][0,0]
[0,2]=[2,0]
[2,3]=[3,2]
[3,6]=[6,3]
[6,6]
[2,2]
[2,1]
[3,3]
[3,4] [3,5]
Figure 2.10: The power of blossoming when applied to a B-Spline curve. The Beziercontrol points are outlined in yellow.
To conclude, note that the matrix CT can now be determined with ease. Just bylooking at the just found Bezier control points, or actually the linear combinations of theB-Spline curve control points, we can supplement CT with one row for each Bezier point.The example from Figure (2.10)/10 is used to obtain the following CT matrix:
CT =
1 0 0 0 00 1 0 0 00 1
323 0 0
0 0 1 0 00 0 3
414 0
0 0 0 1 00 0 0 0 1
The same principle is applicable to B-Splines of higher degrees. Although the complexityincreases a little with higher degrees, it is a very solid and especially graphical method toobtain the CT matrix.
2.3 Finite Element Analysis
FEA can be explained from a lot of different perspectives – some more practical, othersmore mathematically involved (i.e. using function spaces). Here it is presented in an
10
intuitive way. Readers interested in the more formal, mathematical approach are referredto the works of Hughes [Hug00] and Brenner [BS08]. Other highly recommended booksfor general FEA are [ZTN05] and [Bat96]. Additionally, the book of Reddy [Red98] is anexcellent source to learn about function spaces.
2.3.1 Approaching the solution of a differential equation
Let’s not forget that in the end, all FEM really is, is a way to approximate the solution ofa differential equation (either parabolic, like the heat equation, or elliptic, like the Laplaceequation). The unknown field/variable, for instance the temperature or a displacement,is approximated. See Figure (2.11)/11.
Exact solution
Piecewise approximation
Elements
Figure 2.11: The essence of the Finite Element Method (FEM) is approximating thesolution of a differential equation in a piecewise fashion (i.e. using elements).
The solution could be approximated with a high degree polynomial, but the higherthe degree, the more difficult (and in general less stable) it gets. Therefore the domain,i.e. the geometry, is divided into segments, the elements. For each element there is anassociated part of the solution. The division of the domain into individual elements iscalled meshing.
It is comprehensive to explain the concept in 1D, but it is not very practical. Of courseit can be extended to higher dimensions. To keep things relatively simple, from now onwe focus on the 2D case (i.e. the design/geometry/domain is in R2). In this case, thegeometry can be divided into patches – these patches can be bilinear, biquadratic, bicubic,and so on. For quadratic (and higher) degrees, there is also the choice which quadraticbasis to use: Lagrange, Serendipity, Bernstein or another one.
Instead of the control points in CAGD, FEM uses nodes. In case of the elements,these nodes basically function in the same way as the control points – the element (i.e.the surface patch) is the product of the nodes and the shape functions (basis functions),∑n
i=0 PiN(u, v). Note that these shape functions are surfaces as well.Using these elements, the piecewise approximation ~u (e.g. displacement) is found by
solving the system K~u = ~f+~q, where K is the stiffness matrix, ~f a term related to internalloads and ~q a term related to Neumann boundary conditions. The complete approximationfield can then be found by assigning the calculated values (of one component) of ~u as thez-coordinate for the 2D surface nodes, and multiplying these ‘new’ nodes by some set ofbasis functions (compare this to assigning the calculated values u as the y-coordinate inthe 1D case in Figure (2.11)/11, where the 1D curve nodes are the black dots and the ‘new’nodes the white dots).
To summarize, the elements are surface patches, that are formed by the nodes anda set of basis functions. The same is true for the piecewise solution – it is a piecewisesurface. Since surfaces are based on basis functions, now might be a good time to look atdifferent bases from a FEM perspective.
11
2.3.2 FEM and basis functions
It seems a very natural choice to use the same basis functions for both purposes, theelements and the piecewise approximation. This approach is called the isoparametricconcept.
Before the system K~u = ~f + ~q can be setup, some integrals need to be calculated overthe elements and the element boundaries. Because it might be difficult to integrate over anarbitrary 2D element domain (some biquadratic surface), the concept of a master or parentelement is introduced. It is usually defined as the square [−1, 1] × [−1, 1]. The relationbetween the master element and the physical element is a coordinate transformation fromthe parametric coordinates (ξ, η) to the physical coordinates (x, y):
x =
9∑i=1
Ni(ξ, η)xi, y =
9∑i=1
Ni(ξ, η)yi (2.3)
Where xi and yi are the nodal coordinates. This transformation is discussed in some moredetail in Appendix D.2. Note that the displacement ~u can also be written using the shapefunctions (because of the isoparametric concept), i.e. ~u =
∑9i=1Ni(ξ, η)~ui, where ~ui are
the nodal displacements. Using the Einstein summation convention, this can be written alittle more compact as ~u = Ni~ui.
As mentioned before, there is the choice what degree (e.g. linear, quadratic) and whattype (e.g. Lagrange, Serendipity) to use for the elements. Figure (2.12)/12 depicts abilinear element, a biquadratic Lagrange and a biquadratic Serendipity one.
η
ξ
(a) Bilinear element
η
ξ
(b) Lagrange element
η
ξ
(c) Serendipity element
Figure 2.12: Bilinear element, biquadratic Lagrange element and a biquadratic Serendipityelement (in the parametric domain)
The required basis functions for both the bilinear and Lagrange element can be foundby taking the tensor product of the corresponding 1D bases with itself (resulting in 2×2 = 4and 3× 3 = 9 nodes respectively). However, for the Serendipity element this approach isnot possible since there is no center node.
Fortunately there is a simple procedure [Fel04] to find the appropriate basis functionsfor this element. Since this element, like the Lagrangian element, interpolates the nodes,the basis functions should have the Dirac property. This means that at the moment wherethe surface interpolates a node, the corresponding basis function should have value 1,while the others should have value 0 (the 2D basis functions still satisfy the partition ofunity property). Notice that the same property can be observed in the 1D basis, in Figure(2.2a)/4. Because this should hold for all 8 basis functions, only one node in each basisfunction can have a value (the value 1), while the values for the other 7 nodes are 0.
Because of symmetry, there are only two different cases: center nodes and corner nodes,as depicted in Figure (2.13)/13.
The first case, the center node, is the easiest. Just define that the shape function is
12
η
ξ ξ = 1
η = 1
ξ = −1
(a) Center node
η
ξ ξ = 1
η = 1
ξ + η = −1
(b) Corner node
Figure 2.13: Serendipity element: deriving the shape functions.
equal to 0 on the edges where ξ = −1, η = 1 and ξ = 1 (see Figure (2.13a)/13):
Ncenter(ξ, η) = c1(1− η)(1− ξ)(1 + ξ) (2.4)
Next, substitute the coordinates of the node (in this case (ξ, η) = (0,−1)): c1(1−−1)(1−0)(1 + 0) = 2c1. This value has to be equal to 1, therefore c1 = 1
2 . The same procedurecan be followed for the corner nodes. Apart from the edges η = 1 and ξ = 1, the shapefunction in the nodes on the (dashed) line ξ + η = −1 (see Figure (2.13b)/13) should alsobe 0:
Ncorner(ξ, η) = c2(1− η)(1− ξ)(1 + ξ + η) (2.5)
When substituting (ξ, η) = (−1,−1) this results in c2(1 − −1)(1 − −1)(1 − 1 − 1) = −4.Therefore c2 = −1
4 .A good question at this point might be, what the actual difference is between Lagrange
and Serendipity. An obvious difference is that Lagrange elements have n× n = n2 nodes,whereas Serendipity elements only have 2n + 2(n − 2) = 4n − 4 nodes. In our quadraticcase, both elements span a space that is complete in the quadratic sense, but not in ahigher (e.g. cubic) degree. For our purpose the Serendipity element would suffice, becausewe will be using linear elastic analysis, and therefore the deformation of the geometry willbe small. This means that elements will not end up being severely distorted (i.e. there isno use for the extra term provided by the Lagrange basis). Of course, some care should betaken when meshing the geometry. For a detailed discussion about the difference betweenthese elements (and also higher order Lagrange versus Serendipity elements), see [Bat96]and [LB93].
To recapitulate, the elements and solution use the same basis functions (the isopara-metric concept). It is also important to realize that in general all elements use the sameparametric basis .
2.3.3 The stiffness matrix
The general stiffness matrixK is built up (assembled) from the elemental stiffness matrices.Taking the 1D case as example, the elemental stiffness matrix for a linear element (onlytwo nodes) would measure 2 × 2. The Ke for a quadratic element (three nodes) wouldbe of size 3 × 3, a cubic element 4 × 4 and so on. The way the general stiffness matrixis assembled is by placing these Ke matrices in the right position of the general matrix.Because these types of elements always re-use the last node from the previous element,there is an 1×1 overlap. Since Ke is symmetric†, K will be symmetric as well. See Figure
†In our case, Ke is symmetric because we’re looking at linear elasticity. Note however that for othertypes of analysis Ke could be non-symmetric.
13
(2.14)/14 for a graphical explanation of K.
K1 =
a b cb d ec e f
, K2 =
g h ih j ki k l
, K3 =
m n on p qo q r
K =
a b c 0 0 0 0
b d e 0 0 0 0
c e f + g h i 0 0
0 0 h j k 0 0
0 0 i k l +m n o
0 0 0 0 n p q
0 0 0 0 o q r
Figure 2.14: The structure of the general stiffness matrix K, using three 1D quadraticelements.
Going back to the 2D case (using a biquadratic 9-node element), the elemental stiffnessmatrix can be calculated as
Ke =
∫Ve
BTSBdV (2.6)
Where S connects the stress to the strain (we will be using a plane strain condition†),using the equation σ = Sε. These three parts look as follows:
σ =
σxxσyyσxy
, S =E
(1 + ν)(1− 2ν)
1− ν ν 0ν 1− ν 00 0 1
2(1− 2ν)
, ε =
εxxεyyεxy
Where E is the Young’s modulus of the material and ν the Poisson’s ratio. The matrixB is defined using the equality ε = ~∇~u = ~∇Ni~ui = B~ui, so it is the derivative of the localshape functions (functions of the variables ξ and η) differentiated with respect to the globalcoordinates x or y. With the nodal displacements as the row vector
(~u1 ~u2 . . . ~u9
),
where ~ui = (ui, vi), B can be written as
~∇ =
∂
∂x0
0∂
∂y∂
∂y
∂
∂x
B =
∂N1
∂x0
∂N2
∂x0 . . .
∂N9
∂x0
0∂N1
∂y0
∂N2
∂y. . . 0
∂N9
∂y∂N1
∂y
∂N1
∂x
∂N2
∂y
∂N2
∂x. . .
∂N9
∂y
∂N9
∂x
In order to obtain the entries of the B-matrix, we can use the chain rule
∂Ni
∂ξ∂Ni
∂η
=
∂x
∂ξ
∂y
∂ξ∂x
∂η
∂y
∂η
∂Ni
∂x∂Ni
∂y
†Plane strain means that there is only strain in a certain plane (let’s define that as the xy plane). So
εxz, εzx, εyz, εzy and εzz are 0. Note that this does not mean that σzz (the stress in the zz direction) is 0!
14
This 2× 2 matrix is called the Jacobian matrix J . Because of how x and y are defined in(2.3)/12, J can be calculated as
J =
∂x
∂ξ
∂y
∂ξ∂x
∂η
∂y
∂η
=
∑9
i=1
∂Ni
∂ξxi
∑9i=1
∂Ni
∂ξyi∑9
i=1
∂Ni
∂ηxi
∑9i=1
∂Ni
∂ηyi
The components of B can now be calculated using the inverse of J
∂Ni
∂ξ∂Ni
∂η
= J
∂Ni
∂x∂Ni
∂y
⇒
∂Ni
∂x∂Ni
∂y
= J−1
∂Ni
∂ξ∂Ni
∂η
The expression for the inverse of a 2 × 2 matrix can be found in D.1. The final step inorder to be able to calculate (2.6)/14,
dV = dxdy = det(J) dξ dη
Instead of an analytic approach to calculate the integral, often a numerical schemesuch as Gauss integration is used. By strategically placing integration points and usingweighting factors, integrals can be calculated efficiently.
2.4 Splines and analysis: CAGD and FEA combined
After these rather concise explanations of CAGD, Bezier extraction and FEA, let us seewhere they meet. Remember that IGA tells us to use the same basis functions for boththe design (geometry) and the analysis. Combined with the isoparametric concept, thesame basis functions are now used for three different purposes:
1.) The design, i.e. the geometry drawn with the use of some CAD software. It isimportant that this step comes first, so this step actually determines which basisfunctions will be used. The current standard for CAD programs is the NURBSbasis.
2.) The analysis, i.e. the approximation of the solution of some differential equation.
3.) From the isoparametric concept it follows that we can use the same basis for boththe mesh (elements) and for analysis. Therefore the mesh (elements) will use thesame basis as the design!
An important observation from points 1.) and 3.) is that the mesh follows fromthe geometry. Since the same basis functions are used for both purposes, the process ofmeshing becomes an easy and less time consuming task – you can simply indicate where todivide the geometry (i.e. subdividing a B-Spline into smaller B-Splines, but not necessaryup to the Bezier level). These subdivided segments then become the elements – the meshis therefore exact !
An apparent drawback is that using this approach, not all elements use the samebasis anymore – each element uses some B-Spline basis. But remembering the conceptof Bezier extraction, this basis can actually be expressed as some linear combination ofthe Bernstein polynomials (i.e. N = CN). Therefore we can say that each element uses
15
0 0.5 1 1.5 2 2.5 3 3.5 40
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
= C
0 0.5 1 1.5 2 2.5 3 3.5 40
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
Figure 2.15: As demonstrated in the section on Bezier extraction, a B-Spline curve isactually a collection of Bezier curves stitched together. Since the Bezier control points arelinear combinations of the B-Spline control points, so are the basis functions.
the same fundamental basis (the Bernsteins) – but not exactly this basis, but a linearcombination of it. See Figure (2.15)/16.
Therefore, instead of loading a complete basis for each element, it can be reduced toloading a matrix Ce. Using this approach, the only actions to get IGA to work withinan existing FEA software package are implementing an element that uses the Bernsteinbasis, and has the option to import a different extraction matrix Ce for each element.
Another benefit of IGA is that, since the analysis also uses the B-Spline basis, theapproximation will have a higher continuity. This is simply the result of the continuityof the basis itself – a regular FEA basis (e.g. Lagrange) is C0 across element boundaries(and hence the approximation is C0), but the B-Splines (and therefore the approximation)are (degree− 1) continuous! See Figure (2.15)/16.
One of the advantages of this higher continuous approximation is a good conver-gence rate (optionally in combination with a new kind of refinement called k-refinement[CHB09]).
Finally, it is worth looking at the K matrix when using the B-Spline basis. Rememberthat a B-Spline re-uses a lot of control points – in general for each segment, all controlpoints from the previous segment except the first one are re-used. Because of this property,there is now a lot more overlap (compare to Figure (2.14)/14) in the K matrix, as can beseen in Figure (2.16)/16. Notice that K is still symmetric, and that its bandwidth hasremained unchanged.
K =
a b c 0 0
b d+ g e+ h i 0
c e+ h f + j +m k + n o
0 i k + n l + p q
0 0 o q r
Figure 2.16: The structure of the general stiffness matrix K, using three 1D quadraticelements.
16
3 Implementation
This section gives an overview of the workflow – from design and meshing to analysisto evaluating the approximated solution (e.g. displacement, stress). In Appendix B thecomplete (Fortran) code for the resulting IGA-compatible user-element is included, andin Appendix C some interesting parts (Matlab) of both post- and pre-processor are listed.
3.1 Pre-processing
The phase where the object is designed and divided into elements (meshed), and theextraction matrix CT is calculated, is called the pre-processing step.
In Figure (3.1)/17 a complex geometry is shown, which is then split up into 8 elements.The Bezier points that represent the exact same surface can then be determined, resultingin the matrix CT .
Figure 3.1: The used geometry, required B-Spline control points (blue dots) for 8 elements,and the Bezier points (orange circles).
It is not necessary to calculate all these Bezier points – the CT matrix can be deter-mined by taking the tensor product of the two CT
ci matrices of the curves. The CTc1 matrix
for the short straight curve (the one at the left or at the bottom) is
CTc1 =
1 0 0 00 1 0 00 1
212 0
0 0 1 00 0 0 1
The CT
c2 matrix for the other curve (the curved one, or the straight one that has a 90degree kink in it) is
CTc2 =
1 0 0 0 0 0 00 1 0 0 0 0 00 1
212 0 0 0 0
0 0 1 0 0 0 00 0 0 1 0 0 00 0 0 0 1 0 00 0 0 0 1
212 0
0 0 0 0 0 1 00 0 0 0 0 0 1
The total CT can then be calculated [BSEH11] with the tensor product CT
c1 ⊗ CTc2†.
†Note that this type of tensor product is not commutative, i.e. in general CTc1 ⊗ C
Tc2 6= CT
c2 ⊗ CTc1 .
17
The next step is writing the data to a MSC Marc compatible input file [MSC10a]. Thecoordinates of the B-Spline control points are saved, as well as the elements. The elementsare saved as 9 indices, referring to the indices of the corresponding control points. Thesequence in which these points (nodes) should be saved is indicated in Figure (3.2)/18.These lines in the input file together form the connectivity array.
1 2
34
5
6
7
8 9
7 9
31
8
6
2
4 5
Figure 3.2: The nodes are saved in a counter-clockwise fashion, starting with the bottomleft node. As comparison the sequence of control points for a tensor product surface onthe right.
The boundary conditions and material properties also have to be specified in this inputfile, which is rather straightforward.
Finally, in the analysis step the elemental Ce matrices are required, not the global Cmatrix. Figure (3.3)/18, based on the cubic B-Spline curve and cubic Beziers from Figure
(2.6)/7, shows the elemental CTe matrices and how they relate both sets of basis functions
to each other.
1 0 0 0 0 0 0
0 1 0 0 0 0 0
0 12
12 0 0 0 0
0 14
712
16 0 0 0
0 0 23
13 0 0 0
0 0 13
23 0 0 0
0 0 16
23
16 0 0
0 0 0 23
13 0 0
0 0 0 13
23 0 0
0 0 0 16
712
14 0
0 0 0 0 12
12 0
0 0 0 0 0 1 0
0 0 0 0 0 0 1
C1 C2 C3 C4
Figure 3.3: The global extraction matrix CT , where the elemental CTe (i.e. CT
1 , CT2 , CT
3
and CT4 ) matrices are framed. The colors correspond to the basis functions, displayed on
the right.
Note that apart from the matrix Ce per element, the weights wi for the control pointsshould also be loaded in case the geometry was designed using NURBS.
To take care of all these steps, a basic script was written in Matlab. A few components
18
of the code are worthwhile to look at in some detail, see Appendix C.
3.2 The user-element
The next step is implementing a user-element for MSC Marc. Marc has the option to usea custom element (subroutine) that you would like to use to perform the analysis. Thissubroutine reads the input file generated by the Matlab pre-processor (which is moreor less the same as the file generated by MSC Mentat, but optimized and with betteralignment).
The syntax to start the analysis process by MSC Marc is run marc -j input.dat -u
subroutine.f -v n, where input.dat is the file generated by the Matlab pre-processorand subroutine.f the user-element implemented in Fortran.
This input file starts with a number of parameters† (see Basic Input Requirements of[MSC10c]), of which the USER parameter is the most important. This is the place toindicate which kind of analysis should be used (e.g. 5 for plane strain), and on which
topology class the element is based (e.g. 35 for a 9-node quadrilateral).Next part is the connectivity array, which specifies how many elements there are and
which nodes are part of which element, according to the sequence in Figure (3.2)/18. Thecoordinates of the nodes are specified later on.
Subsequently, the boundary conditions are specified, that is, the node numbers onwhich they act. Finally the material parameters are defined. A complete input file isincluded in Appendix A.
The most work is implementing the subroutine in Fortran, the user-element. It iscritical to understand that the subroutine will be evoked multiple times for each element.This is what the IFLAG variable specifies – depending on the value (1 . . . 5), different datais calculated and returned. The values that can occur in our case are
1 – Return the vector F , the prescribed external nodal forces. This value is only presentwhen a boundary condition like an edge load (i.e. a traction) is prescribed.
2 – Return the matrix Xk (i.e. the elemental stiffness matrix Ke) and the vector R (i.e.the internal forces, only non-zero if there is a source).
4 – Return the strains ε and stress σ (in the integration points).
5 – Mode to display/output information.
The subroutine starts by initializing a couple of variables (some IFLAG-dependent),like coordinates of the integration points, elemental stiffness matrix and the materialparameters E and ν. Subsequently, if the IFLAG value is either 2 or 4, there is a loopover the integration points of the element.
In this loop, the basis functions and the derivatives in the point (ξ, η) are calculated.Next, the Jacobian (and its determinant) and the B-matrix are computed (note that theB matrix is required for both IFLAG values 2 and 4).
†Note that not all parameters are documented (yet). For instance, the fourth number of the SIZINGparameter is undocumented – most probably it specifies the sum of the number of nodes each boundarycondition works on.
19
Thereafter, depending on the value of IFLAG, either the stiffness matrix is computed,or the strain is calculated using the displacement that was calculated in a previous step.Subsequently, using the material model, the stress can be calculated from the strain.
IFLAG value 5 provides the option to output/print information, which is very usefulfor testing purposes, and of course to build a structured output file that can be read bythe Matlab post-processor.
In order to get acquainted with the flow of information, at first a very basic sub-routine was implemented – a bilinear quadrilateral element (i.e. 4 nodes per element).Subsequently, it was extended to a biquadratic element. First a Serendipity element (i.e.8-node quadrilateral) was implemented, to compare the results of the subroutine to a na-tive MSC subroutine representing the same element. The next step was to extend this toa Lagrange element, which is not included in the element library of MSC [MSC10b]. Afterchecking the results from this subroutine, the step to a Bernstein element was taken. Likethe Lagrange element, it is a 9-node quadrilateral element, but of course it uses differ-ent basis functions. At this point, the Matlab pre-processor was built, because MSC’spre-processor Mentat cannot generate input files using Bezier elements.
The next important step was implementing the code to load the matrix Ce for anelement. The pre-processor saves these elemental matrices in a separate file – for conve-nience, each 9 × 9 Ce is saved in the same file. Of course this approach results in thestorage of quite some redundant data (because the Ce matrices overlap each other in thegeneral extraction matrix C as shown earlier), but it results in a simpler procedure to loadCe again. Once loaded in the subroutine, the Bernstein basis is multiplied by the rightcoefficients in order to re-construct the B-Spline basis.
Instead of using predefined operators for matrix multiplication or matrix inversion,custom code was written for these purposes. The first operation can be done by using anested loop. For the inversion of the Jacobian matrix, a static procedure was implementedsince this matrix would always measure 2× 2. For completeness, the steps to obtain thesestatic expressions are included in Appendix D.1.
Due to a lack of time it was decided to only use prescribed displacement (i.e. Dirichlet)boundary conditions. Although it should be possible to prescribe nodal loads, this is notquite practical, since in practice it will often be an edge load (i.e. a traction) instead ofindividual nodal loads. As mentioned before, such an edge load needs to be convertedto the vector of equivalent nodal loads F . Even though the process to calculate thesenodal loads is not that complicated, it is not trivial either. Therefore there won’t be anyNeumann boundary conditions, and hence F will always be 0.
Furthermore, the differential equation that is being used (a linear elasticity problem)does not contain a source term, i.e. there are no internal loads (like gravity). Therefore,the vector R will always be 0.
To conclude this section, an overview is provided which illustrates the flow of informa-tion. Please note that it is rather optimized for our specific case, i.e. linear elastic plainstrain with only prescribed displacements and no internal loads. See Figure (3.4)/21.
When the IFLAG=2 step is completed for all elements (i.e. Ke is calculated for allelements), the general stiffness matrix K is assembled by Marc. Since the right handside (remember the equation K~u = ~f + ~q) is also known at this point (a combination of
20
Subroutine IGA.f -- invoked multiple times for each element
Define integration point coordinates (ξ,η) and weights wRead material parameters E, ν and Thickness
If IFLAG has value 2 Initialize stiffness matrix Ke, size (IDSS x IDSS) Initialize internal forces vector REndIf
If IFLAG is less than 5 (i.e. 2 or 4 in our case)
Build material matrix from E and ν Load the elemental extraction matrix Ce from file
Start loop over integration points of the element
Load coordinates of the integration point (ξ,η) Compute value of basis functions and the derivatives in this point Use loaded Ce matrix to get values for the B-Spline basis Calculate Jacobian matrix and its determinant Calculate B-matrix
If IFLAG has value 2 Update the elemental stiffness matrix Ke
ElseIf IFLAG has value 4 (Displacements are known from previous step) Calculate strain (ε11, ε22, ε12) for this integration point Determine the corresponding stresses σ Output physical coordinates of the integration point EndIf
End loop over integration points
ElseIf IFLAG has value 5
Output following data for entire element - Physical coordinates of nodes - Calculated displacement in nodes - Calculated strains in integration points - Calculated stresses in integration points
EndIf
Figure 3.4: Information flow for the analysis step.
the vectors R and F – since both are 0, the right-hand side is 0), Marc can solve thesystem and calculate the displacements ~u. These displacements are then available for theIFLAG=4 step.
Finally, it should be noted that it was not the purpose to implement an optimal user-element. As mentioned before, loading the Ce matrices could have been done in a moreelegant way. In addition there are other parts that could have been implement more neatly,such as the numerical Gauss integration. Instead of using the standard schemes, there isan optimized approach meant for IGA [HRS10].
21
3.3 Post-processing
The third and last step of the workflow is the evaluation of the results from the user-element. For this post-processing step, a script was implemented in Matlab to load thedata and plot it. Some interesting snippets are discussed in Appendix C.
The first thing to do is load the data generated by the user-element. This comprisesthe coordinates of the B-Spline control points and the displacements calculated for thesepoints, the coordinates of the integration points and the strain and stress in these points.The code that describes this algorithm is included in the Appendix.
In order to get a look at the continuity of the solution, the stress field is not plotted byinterpolating the integration points per element (and then extrapolating to the elementboundaries), but by differentiating the displacement field using the B-Spline basis functionsagain (and multiplying the result by some material parameters). In order to realize this,the Ce matrices are imported (the code resembles parts of the code for the user-element).For an extra check, the value of the stress in the integration points is plotted on top ofthe stress surface, as can be seen in Figure (3.5)/22. As expected, they coincide with thesurface.
Figure 3.5: The same stress field, in 2D and 3D. In the 3D version the stress in theintegration points (for 8 elements) is displayed as well.
Apart from plotting the stress field, there is also the option to plot the geometry andthe displacement of the geometry, increased or decreased using a scaling factor (just as inMSC Mentat) – see Figure (3.6)/23.
Since the control points for the quadratic patches are saved in the order indicatedin Figure (3.2)/18, but the tensor product basis functions are used to plot the geometry,some conversion matrix has to be considered. This can be done with a simple 9×1 vector,where each entry points to the right basis function. This vector can be deduced from thereferenced figure.
Finally, in order to visually compare the results (i.e. the stress field) in MSC Mentat(using classical quadratic elements) and the stress field in Matlab, the color profile usedin MSC Mentat was approximated and used in Matlab. See Figure (3.5)/22.
22
Figure 3.6: Original geometry (black) and the deformed geometry (orange) after applyinga uniform displacement on the right edge.
4 Simulations
This section covers the simulations conducted using the user-element. In the early stages,a simple rectangular domain was used to test the subroutines, later on a more complexgeometry was designed.
This more complex geometry represents a square plate with a circular hole – because ofsymmetry, it suffices to only model one quarter of it. Initially the idea was to use NURBS,since a rational curve is required to model the circular part. However, due to the lack oftime, the choice was made to use Non-Uniform B-Splines instead of NURBS (and hencethe circular part is only approximated [DhLr90]).
4.1 Plate with hole
We start by briefly moving through all the steps, from design to evaluation. The boundaryof the geometry is designed using 4 curves – note that the green curve is a single curve,and lies opposite of the approximated circular part (red). See Figure (4.1)/23.
Figure 4.1: The four boundary curves of the geometry, and the fewest number of controlpoints in order to represent the curves with quadratic B-Spline curves.
In order to represent this green line with a quadratic B-Spline curve, there should be
23
a ‘sharp’ basis function. To realize this, there should be a repeating knot in the (reduced)knot-vector Ξ, e.g. Ξ = [0, 0, 1, 1, 2, 2], which results in a minimum of 5 control points†.The short straight edges can be represented by B-Spline curves using a knot-vector likeΞ = [0, 0, 1, 1], resulting in a minimum of 3 control points.
A slight problem is that the approximated circular part (using knot-vector Ξ = [0, 0, 2, 2])is modeled using only 3 control points – if the geometry is to be represented by a tensor-product surface, opposite curves should have the same knot-vector and therefore the samenumber of control points.
Therefore, the circular part should be re-designed using the knot-vector Ξ = [0, 0, 1, 1, 2, 2].In other words, the knot value 1 should be inserted twice. Looking back at blossoming,we see that the circular segment currently is a Bezier curve, and that it can be subdividedinto two parts by locating the label [1, 1] – similar to the example in Figure (2.9)/9.
At this point, the geometry can be designed as the tensor product of the two knot-vectors, resulting in 3× 5 points. Note that it is a single tensor product B-Spline surface,consisting of two separate Bezier surfaces. The minimum number of elements is also 2, asdepicted in Figure (4.2)/24.
Figure 4.2: The geometry represented as a tensor product surface, resulting in a minimumof two elements. Do not confuse the control polygon (dashed black line) with the elements!
Although the geometry can be represented by two elements, in general this is notenough to accurately approximate the solution of the differential equation. Thereforeseveral meshes are created, see Figure (4.3)/24.
Figure 4.3: The same geometry meshed with respectively 18, 24 and 32 elements. Theresulting deformation is plotted in orange.
The pre-processor is able to create .dat input files for MSC Mentat from these meshes,and moreover, create files containing the elemental extraction operators Ce. The boundary
†There is another approach to model this geometry – instead of choosing a repeating knot, an over-lapping control point could be used [HCB05].
24
conditions and material properties are also included in this file. Figure (4.4)/25 providesan overview of the used boundary conditions.
Prescribed displacement u→
Figure 4.4: Since only a quarter of the original geometry is modeled, the appropriateboundary conditions must be used.
The main analysis was performed on the mesh consisting of 8 elements, as depicted inFigure (3.1)/17. The results were already shown in Figure (3.6)/23 (deformation/displace-ments) and in Figure (3.5)/22 (the stress field), but for a more comprehensible version ofthe 3D view, see Figure (4.5)/25.
Figure 4.5: 3D view of the stress field. The designed geometry is used as a base plate inthe xy-plane, the stress is used as values on the z-axis.
In this view, the C0 continuity and C−1 discontinuity between elements can be ob-served. Since the same ‘sharp’ basis function (resulting from the repeated knot) is used toapproximate the displacement in the corner of the plate (actually it is used for the entirecenter line), the displacement will be C0 on this line, and in other places C1. Since thestress is related to the derivative of the displacement, the C−1 discontinuity in the corneris to be expected. In other places it is C0.
Remember that we’re using a quadratic element – an interesting question therefore is
25
how the results would change if we would use a higher order (say cubic) element. Thestress field would still be discontinuous on the center-line, because the knot-vector wouldnow contain a twice-repeated knot. However, in other places the stress field would be C1.Unfortunately, MSC Marc does not offer a topology class to base a cubic user-element on.
It is important to note that in classical FEA, there is a discontinuity between allelements. This is the result of using a basis that is the same for each element, and is C0
across the element boundaries. Post-processors often show the strain and stress field assomething continuous – MSC Mentat is no exception – but again, using classical FEAthese fields are discontinuous. Unfortunately Mentat does not offer a 3D mode to showthis, and the post-processor written in Matlab is not advanced enough to read MSC’s.out files (it actually uses the .log files created by the user-element).
In order to compare the results to classical FEA, the number of elements was graduallyincreased and compared to a classical FEM analysis using quadratic Serendipity elements.As expected, the results match in a very acceptable way.
In the MSC Mentat post-processor it is possible to readout nodal displacement values,with the option RESULTS→ TOOLS→ SHOW NODE, and subsequently clicking on the relevantnode. Furthermore, it is possible to output all sorts of nodal values by selecting theappropriate options in the menu JOBS → PROPERTIES → JOB RESULTS → OUTPUT FILE
→ ANALYSIS RESULTS.
26
5 Conclusions and remarks
Modeling in CAGD is based on tensor product surfaces, using NURBS as a basis. There-fore the differential equation to be solved with FEA is also approximated using NURBS(summarizing the concept of IGA – the same basis for both design and analysis). Due tothe usual short duration of an internship, the rational component was omitted, resultingin NUBS basis functions to be used (i.e. Non-Uniform B-Splines), more generally calledB-Splines.
Since the decomposition of a B-Spline curve into Bezier curves is such a natural process,it is self-evident to use the basis functions for the Bezier curves, the Bernstein polynomials,to represent the B-Splines. This is necessary because it is much more efficient to importa simple matrix for each element, than to load an entire basis function.
In order to generate the geometry and the Ce matrices, a pre-processor was builtin Matlab, and likewise a post-processor was coded to evaluate the results from theuser-element. The boundary conditions were hard-coded, meaning that only one specificsetting was used for analysis. In theory it should also be possible to describe a loadinstead of a displacement, but calculating equivalent nodal loads in order to obtain auniform prescribed load on an edge proved a little too much. The script to generate themesh made it possible to look at the same geometry, each time divided into a differentnumber of elements.
At the post-processing step, the expected continuities due to the B-Splines are (usinga 3D view) clearly visible in the displacement or stress field. The distribution of the strainand stress looks as expected, and when compared to regular FEA, it matches in a veryacceptable way.
As a whole, the objective – implementing the user-element – was accomplished. Theuser-element, albeit very general, shows that the concept works – it is certainly possible tocombine IsoGeometric Analysis with an existing FEA package. In order to make it widerapplicable, a better pre- and post-processor could be written. Perhaps a better idea wouldbe to write a script to convert data from existing CAD programs, and make it ready touse with MSC Marc. The same could be done with the output data from the analysis(there are a some nice post-processing tools available). Finally, besides the Ce matrix, alist of weights should be loaded for each element, in case that rational curves were usedfor the design.
A critical note, or rather a disadvantage, is the fact that MSC Marc does not providethe possibility to implement a bi-cubic element (i.e. an element with 16 nodes). Sincemany CAGD applications are based on cubic curves and surfaces, this is quite a seriousdrawback. After all, the objective is to unite CAGD and FEA as much as possible.Despite the possibility to implement a quadratic IGA compatible element, the inability toimplement an element using a cubic (or in general higher degree) basis is like CAGD andFEA shaking hands – not holding hands.
It is likely that other FEA software packages have similar deficiencies. After all, inclassical FEA, higher order elements are simply not that important. The ones that areavailable are often from the Serendipity family, which do not use a tensor-product basis,and can therefore not be used for IGA.
Nonetheless, the overall conclusion would be that it is definitely possible to implementan IsoGeometric Analysis compatible user-element. Hopefully the interest in the methodkeeps increasing, such that the commercial software packages (or rather the companies)will realize the capabilities this great new approach has to offer.
27
A Input file for MSC Marc
Following is an input file for MSC Marc, generated by the Matlab pre-processor, de-scribing the geometry in Figure (3.6)/23, the boundary conditions and a couple of othersettings.
$-----------------------------------------------------------------------$ Input file for MSC Marc (using quadratic B-Spline elements)$ Created with MATLAB pre-processor by P.J. Barendrecht, May 2012$-----------------------------------------------------------------------extended$-----------------------------------------------------------------------sizing,0,8,28,12alloc,25version,11table,0,0,2,1,1,0,0,1processor,1,1,1,0elastic,0all pointsno echo,1,2,3setnames,2$-----------------------------------------------------------------------elements,-123user,-123,2,4,9,3,2,9,3,1,5,0,,35$-----------------------------------------------------------------------end$-----------------------------------------------------------------------solver,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0optimize,11$-----------------------------------------------------------------------connectivity0,0,11,-123,15,17,3,1,16,10,2,8,92,-123,16,18,4,2,17,11,3,9,103,-123,18,20,6,4,19,13,5,11,124,-123,19,21,7,5,20,14,6,12,135,-123,22,24,10,8,23,17,9,15,166,-123,23,25,11,9,24,18,10,16,177,-123,25,27,13,11,26,20,12,18,198,-123,26,28,14,12,27,21,13,19,20$-----------------------------------------------------------------------coordinates2,28,0,11,0.000000,12.0000002,2.000000,12.0000003,10.000000,12.0000004,12.000000,12.0000005,12.000000,10.0000006,12.000000,2.0000007,12.000000,0.0000008,0.000000,11.0000009,1.873773,11.00000010,8.893994,10.85355311,10.707107,10.70710712,10.853553,8.89399413,11.000000,1.87377314,11.000000,0.00000015,0.000000,7.00000016,1.368867,7.000000
28
17,4.469968,6.26776718,5.535534,5.53553419,6.267767,4.46996820,7.000000,1.36886721,7.000000,0.00000022,0.000000,6.00000023,1.242641,6.00000024,3.363961,5.12132025,4.242641,4.24264126,5.121320,3.36396127,6.000000,1.24264128,6.000000,0.000000$-----------------------------------------------------------------------define,node,set,apply1 nodes1,8,15,22define,node,set,apply2 nodes4,5,6,7define,node,set,apply3 nodes7,14,21,28$-----------------------------------------------------------------------isotropic
1,elastic,isotropic,0,0,0,0,material12.100000000000000+5, 3.000000000000000-1, 0.000000000000000+0,
↪→ 0.000000000000000+0, 0.000000000000000+0, 0.000000000000000+0,↪→ 0.000000000000000+0,0.000000000000000+0
0,0,0,0,0,0,0,01 to 8geometry
3.500000000000000+0, 0.000000000000000+0, 0.000000000000000+0,↪→ 0.000000000000000+0, 0.000000000000000+0, 0.000000000000000+0,↪→ 0.000000000000000+0
1 to 8fixed disp
1,0,0,0,1,0,apply10.000000000000000+0012apply1 nodes1,0,0,0,1,0,apply21.000000000000000+0012apply2 nodes1,0,0,0,1,0,apply30.000000000000000+0022apply3 nodesloadcase3apply1apply2apply3end option$-----------------------------------------------------------------------
29
B The user-element for MSC Marc
The Fortran code below represents a fully functional IGA-compatible user-element forMSC Marc, but as mentioned before, it is not a general element – it is only intendedfor plane strain linear elastic analysis, using only Dirichlet boundary conditions and nointernal loads (i.e. no source present).
The abundance of comments should explain most of the code – for an overview of theflow of information see Figure (3.4)/21.
Note that in general, the approximation is found using an incremental approach (i.e.using the LOADCASE options in MSC Marc/Mentat). In this case, the values for IFLAGwould be repeated each increment – this would require some additional checks in thesubroutine, and of course a different approach to find the final displacements, strains andstresses. The variables used for this method are standard included (like DISP and DE ),but are not used in our element, because a loadcase is not necessary when doing linearelastic analysis.
Fortran code property of Philips.
30
C Interesting parts from the pre- and post-processor code
This section contains some snippets from the pre- and post-processor code written in Mat-lab. From the captions it should be clear what each snippit is supposed to accomplish.
Listing 1: Constructing the tensor-product basis functions (part of the Matlab pre-processor code).
Precision = 100;t = linspace(0,1,Precision);% Qaudratic BernsteinsBernstein = [(1-t).ˆ2; 2*t.*(1-t); t.ˆ2];
% Quadratic Bernstein surfacesNumber = 0;for j=1:3
for i=1:3Number = Number + 1;Basis{Number} = Bernstein(j,:)' * Bernstein(i,:);
endend
Listing 2: Transforming control point/node sequences (part of the Matlab pre-processorcode).
% When creating Ce, the control points are in the CAD sequence, i.e.% 1 2 3% 4 5 6% 7 8 9
% But the User-Element of course expects them to be in the FEA sequence, i.e.% 4 7 3% 8 9 6% 1 5 2
% Use a vector with the indices 1...9 to fix the problem:Nodes = [7 9 3 1 8 6 2 4 5];
Listing 3: Saving the Ce matrices (part of the Matlab pre-processor code).
dlmwrite([FileName, ' Extraction'], CC{1}', 'delimiter', ' ')for i=2:nElem
dlmwrite([FileName, ' Extraction'], CC{i}', 'delimiter', ' ', '-append')end
Listing 4: Storing the connectivity array and the coordinates of the nodes (part of theMatlab pre-processor code).
fprintf(fileID,'%s\n','$-------------------------------------------------------↪→ ----------------');
fprintf(fileID,'%s\n','connectivity');fprintf(fileID,'%s\n','0,0,1');
% Elements
31
for i=1:nElemfprintf(fileID,'%d,-123',i);fprintf(fileID,',%d',Elements(i,:));fprintf(fileID,'%s\n','');
end
fprintf(fileID,'%s\n','$-------------------------------------------------------↪→ ----------------');
fprintf(fileID,'%s\n','coordinates');% Number of nodesfprintf(fileID,'2,%d,0,1\n',b*c);
% Nodesfor i=1:b*c
fprintf(fileID,'%d',i);fprintf(fileID,',%f',P(i,:));fprintf(fileID,'%s\n','');
end
fprintf(fileID,'%s\n','$-------------------------------------------------------↪→ ----------------');
Of course the actual design of the domain is an important part, but in this elaboratepiece of code nothing really special happens (just some elementary geometric calculations).Moreover, a rather static method is used to find the extraction matrix C. Let’s now turnour attention to the post-processor.
Listing 5: Loading the calculated data (part of the Matlab post-processor code).
% Sequence of saved data in the .log file% Coordinates, Displacements, Strains, StressesSequence = [9,2; 9,2; 9,3; 9,4];
% Initialize data structuresIntPnt = zeros(nElem, 9, 2);Coordinates = zeros(nElem, 9, 2);Displacements = zeros(nElem, 9, 2);Strain = zeros(nElem, 9, 3);Stress = zeros(nElem, 9, 4);
Index = 1;Type = 0;Elem = 1;
fid = fopen( [FileName, '.log']);
while 1tline = fgets(fid);
if ¬ischar(tline)break
end
if tline(1) == '('Nums = str2num(tline(4:end));
% First load the coordinates of the Integration Pointsif Type == 0
32
IntPnts(Elem, Index, 1) = Nums(1);IntPnts(Elem, Index, 2) = Nums(2);Index = Index + 1;
% There are 9 Integration Pointsif Index > 9
Index = 1;Elem = Elem + 1;
end
% When finished with loading the Integration Pointsif Elem > nElem
Type = 1;Elem = 1;
end
else
switch Typecase 1
Coordinates(Elem, Index, 1) = Nums(1);Coordinates(Elem, Index, 2) = Nums(2);
case 2Displacements(Elem, Index, 1) = Nums(1);Displacements(Elem, Index, 2) = Nums(2);
case 3Strain(Elem, Index, 1) = Nums(1);Strain(Elem, Index, 2) = Nums(2);Strain(Elem, Index, 3) = Nums(3);
case 4Stress(Elem, Index, 1) = Nums(1);Stress(Elem, Index, 2) = Nums(2);Stress(Elem, Index, 3) = Nums(3);Stress(Elem, Index, 4) = Nums(4);
end
Index = Index + 1;
% Go on with next part (Displacements, Strain, Stress)if Index > Sequence(Type,1)
Index = 1;Type = Type + 1;
end
% Start with next elementif Type > 4
Type = 1;Elem = Elem + 1;
end
end % End of Type=0 Check
else % Line does not start with a bracket% Skip (possibility to print something)
end
end % End of the file
fclose(fid);
33
Listing 6: Loading the Ce matrices (part of the Matlab post-processor code).
CC = dlmread([FileName, ' Extraction'], ' ');for i=1:nElem
C{i} = zeros(9,9);C{i} = CC( 1+(i-1)*9:i*9 , :);
end
After plotting the domain and the deformed domain (i.e. the nodal displacementsadded to the original coordinates of the nodes), either the displacement, strain or stressfield is plotted (in 3D). A lot of the preceding code is very similar to code in the user-element (but now of course written in Matlab). One last interesting part is the actual3D plotting procedure.
Listing 7: Plotting the 3D field (e.g. Stress) (part of the Matlab post-processor code).
D11 = E*(1-Nu) / ((1+Nu) * (1 - 2*Nu));D12 = E*Nu / ((1+Nu) * (1 - 2*Nu));
for Alpha = 1:Precisionfor Beta = 1:Precision
% ...
Stress11 = D11*Strain11 + D12*Strain22;StressField(Alpha,Beta) = Stress11;
endend
X = zeros( Precision, Precision );Y = zeros( Precision, Precision );
for n = 1:9 % Number of nodesX = X + Coordinates(K,n,1) * Shp{n};Y = Y + Coordinates(K,n,2) * Shp{n};
end
mesh(X,Y,StressField)
load('MyColorMap', 'MSC Mentat')set(gcf,'ColorMap', MSC Mentat)% Min and Max are the minimum and maximum values of Stressfieldcolorbar('YTick',linspace(Min,Max,15))
34
D Background on FEM related topics
In this appendix, some elementary but important FEA-related background informationis provided in order to increase the comprehensibility of both FEA in general, but inparticular the code of the user-element.
D.1 Inverse of a 2× 2 matrix
In the user-element the inverse of the 2× 2 Jacobian matrix has to be determined. Directexpressions for an inverse are of course faster than using general algorithms for calculatingan inverse. Therefore it is worthwhile to elucidate the simple steps to obtain these directexpressions.
The inverse of a 2× 2 matrix (provided that it exists) can be found as follows:
A =
(a bc d
), A−1 =
(e fg h
)A A−1 =
(ae+ bg af + bhce+ dg cf + dh
)= I =
(1 00 1
)So we end up with four equations
ae+ bg = 1
ce+ dg = 0
af + bh = 0
cf + dh = 1
Multiplying the first one by d, the second one by b, and subtracting the two, we get
dae+ dbg = d (1)
bce+ bdg = 0 (2)
⇒ (1)− (2) = dae− bce = e(ad− bc) = d⇒ e = d/(ad− bc)
In order to get g, we just substitute this result into the second equation:
ce+ dg = 0⇒ g = −ce/d= −c (d/(ad− bc)) /d = −c/(ad− bc)
Using the same workflow (multiplying the third equation by d and the fourth by b andthen subtracting them), we end up with f = −b/(ad− bc) and h = a/(ad− bc). So finally,
A−1 =1
ad− bc
(d −b−c a
).
35
D.2 Change of variables
The change of variables part may perhaps look trivial, but it’s important to know thebackground of this part. Therefore the 1D case is briefly explained. The change of variablesis required because of the introduction of the master (or parent) element.
If a function g maps t to x (i.e. g : t → x, or x = g(t)), and a function F maps thisx to y (i.e. F : x → y, or y = F (x)), then t is effectively mapped to y. This map is acomposite function:
F ◦ g : t→ y
(F ◦ g)(t) ≡ F (g(t))
Assume that f(x) is continuous (so an anti-derivative F (x) exists) and g′(t) is continuouson the interval [a, b] (so in short, f(x) ∈ C0 and g(t) ∈ C1). Then f (g(t)) g′(t) is alsocontinuous on [a, b]. Next, we can rewrite (using the chain rule)
(F ◦ g)′(t) = F (g(t))′ = F ′(g(t))g′(t) = f(g(t))g′(t)
Because x = g(t), it follows that
dx
dt= g′(t)⇒ dx = g′(t) dt (D.1)
And therefore ∫ b
af(g(t))g′(t) dt =
∫ b
a(F ◦ g)′(t) dt =
∫ b
aF (g(t))′ dt
= F (g(b))− F (g(a)) =
∫ g(b)
g(a)f(x) dx.
36
References
[AS10] Lars-Erik Andersson and Neil Frederick Stewart. Introduction to the Mathe-matics of Subdivision Surfaces. SIAM, 2010.
[Bat96] Klaus-Jurgen Bathe. Finite element procedures. Prentice Hall, 1996.
[BBB95] Richard H. Bartels, John C. Beatty, and Brian A. Barsky. An Introductionto Splines for Use in Computer Graphics And Geometric Modeling. MorganKaufmann, 1995.
[BCRV12] Rene De Borst, Mike Crisfield, Joris Remmers, and Clemens Verhoosel. Non-linear Finite Element Analysis of Solids and Structures. John Wiley & Sons,2012.
[BHR93] Carl De Boor, Klaus Hollig, and Sherman Riemenschneider. Box Splines.Springer, 1993.
[BS08] Susanne C. Brenner and L. Ridgway Scott. The Mathematical Theory of FiniteElement Methods. Springer, 2008.
[BSEH11] Michael J. Borden, Michael A. Scott, John A. Evans, and Thomas J. R. Hughes.Isogeometric finite element data structures based on bzier extraction of nurbs.International Journal for Numerical Methods in Engineering, 87:15–47, 2011.
[CHB09] J. Austin Cottrell, Thomas J. R. Hughes, and Yuri Bazilevs. IsogeometricAnalysis: Toward Integration of CAD and FEA. John Wiley & Sons, 2009.
[dB01] Carl de Boor. A Practical Guide to Splines. Springer, 2001.
[dC63] P. de Casteljau. Courbes et surfaces a poles. Technical report, Andre CitroenAutomobiles SA, 1963.
[dC93] Paul de Casteljau. Polar forms for curve and surface modeling as used atcitroen. In Les Piegl, editor, Fundamental Developments of Computer-AidedGeometric Modeling. Academic Press, 1993.
[DhLr90] Tor Dokken, Morten Dæhlen, Tom Lyche, and Knut Mørken. Good approxi-mation of circles by curvature-continuous bezier curves. Computer Aided Geo-metric Design, 7:33 – 41, 1990.
[Far99] Gerald E. Farin. NURBS: from projective geometry to practical use. A.K.Peters, 1999.
[Far02] Gerald E. Farin. Curves and Surfaces for Cagd: A Practical Guide. MorganKaufmann, 2002.
[Fel04] Carlos A. Felippa. Introduction to Finite Element Methods, chapter 18. Uni-versity of Colorado, 2004.
[Gal99] Jean Gallier. Curves and Surfaces In Geometric Modeling: Theory And Algo-rithms. Morgan Kaufmann, 1999.
[Gol03] Ron Goldman. Pyramid Algorithms: A Dynamic Programming Approach toCurves and Surfaces for Geometric Modeling. Morgan Kaufmann, 2003.
37
[HCB05] T.J.R. Hughes, J.A. Cottrell, and Y. Bazilevs. Isogeometric analysis: Cad,finite elements, nurbs, exact geometry and mesh refinement. Computer Methodsin Applied Mechanics and Engineering, 194:4135 – 4195, 2005.
[HRS10] T.J.R. Hughes, A. Reali, and G. Sangalli. Efficient quadrature for nurbs-basedisogeometric analysis. Computer Methods in Applied Mechanics and Engineer-ing, 199:301 – 313, 2010.
[Hug00] Thomas J. R. Hughes. The finite element method: linear static and dynamicfinite element analysis. Dover Publications, 2000.
[LB93] Nam-Sua Lee and Klaus-Jurgen Bathe. Effects of element distortions on theperformance of isoparametric elements. International Journal for NumericalMethods in Engineering, 36:3553–3576, 1993.
[Man06] Stephen Mann. A Blossoming Development of Splines. Morgan & ClaypoolPublishers, 2006.
[MSC10a] MSC Software. Marc Volume C: Program Input, 2010.
[MSC10b] MSC Software. Volume B: Element Library, 2010.
[MSC10c] MSC Software. Volume D: User Subroutines and Special Routines, 2010.
[PR08] Jorg Peters and Ulrich Reif. Subdivision Surfaces. Springer, 2008.
[Pra84] H. Prautzsch. Unterteilungsalgorithmen fiir multivariate Splines. PhD thesis,Univ. Braunschweig, 1984.
[Ram87] Lyle Ramshaw. Blossoming: a connect-the-dots approach to splines. DigitalEquipment Corporation. Systems Research Center, 1987.
[Ram89] Lyle Ramshaw. Blossoms Are Polar Forms. Digital Systems Research Center,1989.
[Red98] B. Dayanand Reddy. Introductory Functional Analysis: With Applications toBoundary Value Problems and Finite Elements. Springer, 1998.
[RS04] L Romani and M.A Sabin. The conversion matrix between uniform b-splineand bzier representations. Computer Aided Geometric Design, 21:549 – 560,2004.
[Sal06] David Salomon. Curves And Surfaces for Computer Graphics. Springer, 2006.
[Sei93] Hans-Peter Seidel. An introduction to polar forms. Technical report, Universityof Erlangen, 1993.
[ZTN05] O. C. Zienkiewicz, Richard Lawrence Taylor, and Perumal Nithiarasu. TheFinite Element Method. Butterworth-Heinemann, 2005.
38