T.

Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Abaqus User Element implementation of
NURBS based Isogeometric Analysis
T. Elguedj
1
, A. Duval
1
, F. Maurin
1
, H. Al Akhras
1
1
Universite de Lyon, CNRS
INSA-Lyon, Laboratoire de Mecanique des Contacts et des Structures, France
6
th
European Congress on Computational Methods in Applied Science and
Engineering
Vienna, Austria Sep. 10
th
- Sep. 14
th
2012
1 / 22
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Outline
1 Introduction
2 Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
3 Numerical examples
Linear elasticity
Nonlinear material models
4 Conclusions and future work
2 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Outline
1 Introduction
2 Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
3 Numerical examples
Linear elasticity
Nonlinear material models
4 Conclusions and future work
3 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Introduction
Isogeometric Analysis is based on the
geometric primitives of CAD: NURBS and
T-splines. It includes standard FEA as a
special case, but oers other possibilities:
Precise and ecient geometric
modeling
Simplied mesh renement
Smooth basis functions with compact
support
Superior approximation properties
Accurate derivatives and stresses
Integration of design and analysis
Application in industry requires its
implementation in commercial soft-
ware
4 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Introduction
Several commercial FE packages provide user element capabilities.
Abaqus User ELement and User ELement with abaqus MATerial
subroutine oers the possibility to introduce arbitrary elements into
abaqus using user dened material models (UEL) or most of the
material models available in the software (UELMAT).
UEL can be dened with arbitrary shape functions, node numbers,
polynomial order and integration points.
All the standard nite element data can be passed in the .inp input
le.
Additional data can be passed as common variables using User
EXTERNAL DataBase (UEXTERNALDB) routines.
5 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Outline
1 Introduction
2 Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
3 Numerical examples
Linear elasticity
Nonlinear material models
4 Conclusions and future work
6 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Single patch implementation
P1: ABC/ABC P2: c/d QC: e/f T1: g
c03 JWBK372-Cottrell May 20, 2009 15:22 Printer Name: Yet to Come
NURBS as a Basis for Analysis 95
Start
Read input
data
Build connectivities and allocate
global arrays
Loop through elements
Loop through quadrature
points
Add contributions to
K
e
and F
e
Assemble K
e
K
and F
e
F
Evaluate basis functions
and derivatives
Solve Kd=F
Stop
K
e
=0 and F
e
=0
K=0 and F=0
Write
output data
Figure 3.15 Flowchart of a classical nite element code. Such a code can be converted to a single-patch
isogeometric analysis code by replacing the routines shown in green.
use the connectivity information to add their contributions to the global stiffness matrix and
force vector, and then move on to the next element. After all of the elements are assembled,
the global arrays are complete. We then solve the system, write the result to a le, postprocess,
and we are nished. See Hughes, 2000 for further details.
To convert an existing nite element code to a single-patch isogeometric analysis code, the
only portions of the code that require modication are the ones shown in green in Figure 3.15.
Clearly, the input will change as the le format will depend on the specic element technology
being used. The precise forms of the connectivity arrays and the global matrices also depend
on the basis. The structured nature of the NURBS mesh means that the IEN array (see Section
3.3.1.4) can be calculated automatically from the knot vectors and polynomial orders. Next,
the black box that evaluated the basis functions must be updated to evaluate the NURBS
functions. This is why we emphasized the modular nature of this routine previously: the type
of information about the basis that it provides to the routine that calls it is exactly the same,
but that information should now correspond to the NURBS basis. Lastly, the output must be
written, and the format of that output will be specic to the NURBS basis.
J.A. Cottrell, T.J.R. Hughes, Y. Bazilevs Isogeometric Analysis, 2009.
7 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
FEA vs. IGA data
Finite Element Analysis
node coordinates
element type
element connectivity (ID, IEN
and LM)
integration rule
NURBS based IGA
control points coordinates
polynomial degree
element connectivity (ID, IEN,
LM, INC)
integration rule
control points weights
knot vectors
Common data can be passed in the .inp abaqus input le. We only
consider same polynomial order in all parametric directions, therefore
element type denes the degree. Gauss quadrature is dened a priori based
on element type.
8 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Connectivity
Given a basis function (i.e. control point) number and a parametric
direction, the INC array returns the NURBS coordinate.
Given a local basis function number and element number, the IEN
array returns the global basis function number.
Given a global basis function number and degree of freedom number,
the ID array returns the equation number.
The IEN array is directly passed in the .inp le with the standard
element connectivity.
The ID array is generated by abaqus based on the boundary
conditions and number of DOF per CP.
9 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Connectivity
Given a basis function (i.e. control point) number and a parametric
direction, the INC array returns the NURBS coordinate.
Given a local basis function number and element number, the IEN
array returns the global basis function number.
Given a global basis function number and degree of freedom number,
the ID array returns the equation number.
The INC array is used in the pre-processing step to construct IEN but
only a part of it is necessary in the shape function routine. For each
element and parametric direction we only need the NURBS
coordinate of the rst local basis function. We replace INC by a new
array called NIJK.
Given an element number and a parametric direction, the NIJK array
returns the NURBS coordinate of the rst local basis function.
9 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Multi-patch implementation
P1: ABC/ABC P2: c/d QC: e/f T1: g
c03 JWBK372-Cottrell May 20, 2009 15:22 Printer Name: Yet to Come
96 Isogeometric Analysis: Toward Integration of CAD and FEA
3.6.1.1 A multiple patch code
A multi-patch isogeometric analysis code can be made to conform with the owchart in
Figure 3.15. In practice, however, it makes more sense to consider the slight modication
shown in Figure 3.16. In this case, we begin by inputting enough global information to build
the global connectivities, as before. This information includes the polynomial orders and the
knot vectors for each of the patches, but it does not require the control points. We can save
time and memory by not reading the control points until they are needed. If local renement
Start
Read global
input data
Build connectivities and allocate
global arrays
Loop through elements
on the current patch
Loop through quadrature
points
Add contributions to
K
e
and F
e
Assemble K
e
K
and F
e
F
Evaluate basis functions
and derivatives
Solve Kd=F
Stop
K
e
=0 and F
e
=0
K=0 and F=0
Write
output data
Loop through patches
Read patch
input data
Figure 3.16 Flowchart of a multi-patch isogeometric analysis code. The routines in green represent
differences from the single-patch code.
10 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Multi-patch implementation
The outer loop on patches cannot be used within abaqus.
For simplicity we only support C
0
coupling with conforming meshes.
The connectivity arrays for all patches are generated in the
pre-processing step.
Then a global reordering of the elements and control points is done
with a merging of CP on patch interfaces.
The .inp le is generated for the whole domain as for a single patch.
Patch data is passed in the .NB le.
P1: ABC/ABC P2: c/d QC: e/f T1: g
c03 JWBK372-Cottrell May 20, 2009 15:22 Printer Name: Yet to Come
NURBS as a Basis for Analysis 87
which we insert into (3.58) along with w|
D
= 0 to arrive at

w u d+

wf d+

R
wr d

R
wu d = 0. (3.61)
Though we have replaced one expression involving the unknown u for another, we have
enforced the relationship between them weakly.
3.5 Multiple patches revisited
3.5.1 Local renement
In Section 3 of Chapter 2 we discussed the need for modeling domains using multiple patches.
We always assume compatible discretizations for the geometry, meaning that on the coarsest
mesh, mappings and parameterizations on the adjoining patch faces are identical. Each control
point on a face is in one-to-one correspondence with a control point from the adjoining face,
likewise for the control variables of the solution. In many instances, this relationship will be
preserved as we rene. To make the assembly of the stiffness matrices and force vectors as
simple as possible, the connectivity array will identify the equivalent local control variables
on each face with a single control variable in the global array. By identifying them as a single
entity for analysis purposes, we simplify the logic and decrease the total amount of work
needed. The result is that the two patches are joined as though they were one.
Identifying two control points at the same location in physical space as being a single entity
is fairly trivial. Slightly subtler is what this implies for the basis functions. The situation is
shown in Figure 3.7. When two bases generated using open knot vectors are brought together,
the effect is indistinguishable from the case of one knot vector with a knot repeated p times,
as long as the coefcients of the two joining functions are the same. This is, of course, exactly
what we have assured by identifying the two control variables as one.
Figure 3.7 If two knot vectors formed from open knot vectors are brought together, they can be made
to act as one if the coefcients (i.e., control variables) of the two functions on their interface are always
equal to each other. The result is indistinguishable from the case of a single knot vector with a C
0
boundary at the interface.
10 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
.inp le
*HEADING
**Job name:test.txt
**abqNURBS - Laboratoire de Mecanique des Contacts et des Structures - INSA-Lyon
*Part, name=Piece
*USER ELEMENT, NODES=ncpelt, TYPE=Up, COORDINATES=d, variables=size of SVARS,
INTEGRATION=ngelt, TENSOR=PSTRAIN or THREED
1,2 for 2D, 1,2,3 for 3D
*Node,nset=AllNode ->list of control points
cpnb, X-coordinate, Y-coordinate, Z-coordinate
*Element, type=Up, elset=AllEls -> list of elements
eltnb, CP1, CP2, CP3, ...
*ELSET,ELSET=EltPAtch1 -> set of all the elements
list of elements nb
*NSET,NSET=SetCPFacei -> set of control points used for Dirichlet BC
list of control points lying on the i-th face
*ELSET, ELSET=SetEltFacei -> set of elements used for Neumann BC
list of elements belonging to the i-th face
*UEL PROPERTY, ELSET=EltPatch1, MATERIAL=MAT ->assign the material to the set of all elements
*End Part
** ASSEMBLY
*Assembly, name=Assembly
*Instance, name=I1, part=Piece
*End Instance
*End Assembly
11 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
.inp le
**MATERIAL
*MATERIAL,NAME=MAT
*Elastic
Youngs modulus value, Poissons ratio value
*STEP,extrapolation=NO,NLGEOM=YES or NO
*Static
** BOUNDARY CONDITIONS ->list of Dirichlet boundary conditions
*Boundary
I1.SetCPFacei, direction of the imposed BC, direction of the imposed BC, value imposed.
** LOADS ->list of Neumann boundary conditions
*Cload
I1.SetFacei, key for selecting element face, value imposed.
** OUTPUT REQUESTS
*node file, frequency=1
U,RF,CF
*el file, frequency=1
SDV
*End Step
11 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
.NB le
*DIMENSION
2 or 3
* total nb of elements
nelt
*nb of patches
nbpatch
*nb of elements per patch
neltp1, neltp2, ...
*data for patch i
number of knots for parametric direction j
knot vector for parametric direction j
*NIJK array based on global domain element numbering
eltnb, nijk1, nijk2, nijk3
*list of CP weights based on global domain CP numbering
CPnb, weight
12 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Procedure
1 Pre-processing
Matlab pre-processor based on Geopdes. Handles 2D, 3D single
and multi-patch cases.
Rhino plugin for multi-patch 2D cases (imposition of BC,
material denition).
2 Analysis
3 Post-processing
13 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Procedure
1 Pre-processing
2 Analysis
GUI for selecting IGA input les.
Interactive job execution using our IGA user element.
3 Post-processing
13 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Procedure
1 Pre-processing
2 Analysis
3 Post-processing
Request output of the results in a raw ASCII le .l (CP data,
internal variables).
GUI user interface for selecting input and output les and
post-processing parameters.
Abaqus python and C++ scripting interface to perform
projection on a ner FE mesh. (Internal variables are rst
projected onto CP using global least-square if needed).
Generate a projected output database binary le .odb readable
in abaqus CAE.
13 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Graphical User Interface
movie
14 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Outline
1 Introduction
2 Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
3 Numerical examples
Linear elasticity
Nonlinear material models
4 Conclusions and future work
15 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Linear elasticity: single patch horseshoe
E= 100 000MPa, = 0.3, imposed displacement of u
d
= +/ 1e
x
.
T.J.R. Hughes, J.A. Cottrell, Y. Bazilevs
Isogeometric analysis: CAD, nite elements, NURBS, exact geometry and
mesh renement. Computer Methods in Applied Mechanics and
Engineering, vol. 194, p. 41354195, 2005.
16 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Linear elasticity: single patch horseshoe (contd)

zz
on initial conguration
zz
on deformed conguration
17 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Linear elasticity: multipatch cylinder
Cylinder submitted to internal pressure, geometry dened with 4 patches.
R = 2m, r = 1m, E = 100000MPa, = 0.3, p=10MPa.
Von Mises stress on deformed
conguration
undeformed geometry and mesh.
18 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Small strain plasticity: plane strain cylinder
Cylinder submitted to internal pressure, elastic vs. perfectly plastic case.
R = 2m, r = 1m, E=200000MPa, = 0.3,
y
=200MPa, p=145MPa.
Von Mises stress pure elastic case
(
min
vm
= 85MPa ;
MAX
vm
=335MPa)
Von Mises stress perfectly plastic
case (
min
vm
= 116MPa ;

MAX
vm
=200MPa)
19 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Outline
1 Introduction
2 Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
3 Numerical examples
Linear elasticity
Nonlinear material models
4 Conclusions and future work
20 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Conclusions
We have a proposed an implementation of NURBS based IGA in the
abaqus FEA commercial package.
The implementation is able to handle single and multiple patches (C
0
continuity across compatible patch boundaries).
Thank to UELMAT we can directly use most material models
available in abaqus for small and large deformation (NLGEOM).
Post processing capabilities are available directly into abaqus CAE
using Python/C++ scripting interface.
Preliminary work on pre-processing allow us to provide a GUI for 2D
cases and matlab for 3D.
21 / 22
Introduction
Implementation
FEA vs. IGA
Multiple patches
Input les
Procedure and GUI
Numerical
examples
Linear elasticity
Nonlinear material
models
Conclusions
T. Elguedj
abqNURBS
09/12/2012
ECCOMAS 2012
Future work
Improve the way necessary extra data can be passed on (i.e. outside
the .inp le).
Introduce Bezier extraction as an alternative.
Include temperature for thermal or thermo-mechanical analysis,
further test NLGEOM and material models as well as dynamics.
Released as open source under the CeCILL license in a few days.
http://abqnurbs.insa-lyon.fr
22 / 22