Shell Elements in Abaqus, PolyUMod, and MCalibration

Introduction

Abaqus shell elements seem easy to use at first sight, just define the elements using keywords like the following:
*Element, type=S4, elset=all
1, 1, 2, 3, 4
*Shell section, elset=all, material=Mat
0.01

This type of element definition works in both Abaqus/Standard and Abaqus/Explicit, but you may be surprised to learn that this approach can give different results when run using Abaqus/Standard and Abaqus/Explicit!

To demonstrate this difference I created a simple one-element test case in 3 different ways. The element is deformed uniaxially in the horizontal direction, the vertical and through-thickness displacements are free.

*Heading
Created by MCalibration
*Preprint, echo=NO, model=NO, history=NO, contact=NO
**
** PARTS
**
*Part, name=SpecimenPart
*Node, nset=all
1, 0, 0, 0
2, 0, 0, 0.01
3, 1, 0, 0.01
4, 1, 0, 0
5, 0, 1, 0
6, 0, 1, 0.01
7, 1, 1, 0.01
8, 1, 1, 0
*Nset, nset=nLeft
1, 2, 5, 6
*Nset, nset=nBot
1, 2, 3, 4
*Nset, nset=nBack
1, 4, 5, 8
*Nset, nset=nFront
2, 3, 6, 7
*Nset, nset=nTop
5, 6, 7, 8
*Nset, nset=nRight
3, 4, 7, 8
*Element, type=C3D8, elset=all
1, 1, 2, 3, 4, 5, 6, 7, 8
*Solid section, elset=all, material=Mat
*End Part
**
*Assembly, name=Assembly
*Instance, name=Specimen, part=SpecimenPart
*End Instance
*End Assembly
**
** MATERIALS
**
*Material, name=Mat
*Elastic
1.0, 0.4
*Boundary
Specimen.nLeft, 1
Specimen.nBot, 2
Specimen.nBack, 3
** ----------------------------------------------------------------
*Step, nlgeom, inc=90000
*Static
0.1, 1.0, 1.0e-6, 0.1
*Boundary
Specimen.nRight, 1, 1, 1.0
*Restart, write, frequency=0
*Output, field
*Node Output
u
*Element Output
s, le
*Output, history, op=NEW
*Element Output, elset=Specimen.all
s, le
*Node Output, nset=Specimen.nRight
u1, rf1
*El Print, freq=0
*Node Print, freq=0
*End step
*Heading
Created by MCalibration
*Preprint, echo=NO, model=NO, history=NO, contact=NO
**
** PARTS
**
*Part, name=SpecimenPart
*Node, nset=all
1, 0, 0
2, 1, 0
3, 1, 1
4, 0, 1
*Nset, nset=nLeft
1, 4
*Nset, nset=nBot
1, 2
*Nset, nset=nTop
3, 4
*Nset, nset=nRight
2, 3
*Element, type=S4, elset=all
1, 1, 2, 3, 4
*Shell section, elset=all, material=Mat
0.01
*End Part
**
*Assembly, name=Assembly
*Instance, name=Specimen, part=SpecimenPart
*End Instance
*End Assembly
**
** MATERIALS
**
*Material, name=Mat
*Elastic
1.0, 0.4
*Boundary
Specimen.nLeft, 1
Specimen.nBot, 2
** ----------------------------------------------------------------
*Step, nlgeom, inc=90000
*Static
0.1, 1.0, 1.0e-6, 0.1
*Boundary
Specimen.nRight, 1, 1, 1.0
*Restart, write, frequency=0
*Output, field
*Node Output
u
*Element Output
s, le
*Output, history
*Element Output, elset=Specimen.all
s, le
*Node Output, nset=Specimen.nRight
u1, rf1
*El Print, freq=0
*Node Print, freq=0
*End step
*Heading
Created by MCalibration
*Preprint, echo=NO, model=NO, history=NO, contact=NO
**
** PARTS
**
*Part, name=SpecimenPart
*Node, nset=all
1, 0, 0
2, 1, 0
3, 1, 1
4, 0, 1
*Nset, nset=nLeft
1, 4
*Nset, nset=nBot
1, 2
*Nset, nset=nTop
3, 4
*Nset, nset=nRight
2, 3
*Element, type=S4, elset=all
1, 1, 2, 3, 4
*Shell section, elset=all, material=Mat
0.01
*End Part
**
*Assembly, name=Assembly
*Instance, name=Specimen, part=SpecimenPart
*End Instance
*End Assembly
**
** MATERIALS
**
*Material, name=Mat
*Elastic
1.0, 0.4
*Density
1.0e-9
*Boundary
Specimen.nLeft, 1
Specimen.nBot, 2
** ----------------------------------------------------------------
*Step, nlgeom=yes
*Dynamic, explicit
, 1.0
*Amplitude, name=damp
0.0, 0.0, 1.0, 1.0
*Variable mass scaling, freq=1, dt=2.0e-6, type=uniform
*Boundary, amplitude=damp
Specimen.nRight, 1, 1, 1.0
*Output, field, number interval=100
*Node Output
u
*Element Output
s, le
*Output, history, time interval=2.0e-3
*Element Output, elset=Specimen.all
s, le
*Node Output, nset=Specimen.nRight
u1, rf1
*End step

Abaqus Results

When I run these test cases I get the the same predicted stress-strain behavior, as seen in the following figure. This is exactly what one would expect, of course.

What is perhaps surprising is that if I plot the force-displacement response, instead of the stress-strain response, then I get different results from Abaqus/Explicit and Abaqus/Standard. See the following figure.

There are clearly two groups of curves in this figure. We see that 3D elements (here, C3D8) give the same results as shell elements with Abaqus/Explicit, but the response from Abaqus/Standard with shell elements is softer. The reason for this difference is caused by the  different contraction of the element thickness in Abaqus/Standard and Abaqus/Explicit. In other words, the through-thickness response is different.

If you read about *SHELL SECTION in the Abaqus User’s Manual you will find that there is an optional parameter called POISSON with the following description. Note that the default behavior is different between Standard and Explicit.

Include this parameter to define the shell thickness direction behavior. Set this parameter equal to a nonzero value to cause the thickness direction strain under plane stress conditions to be a linear function of the membrane strains. The value of the POISSON parameter must be between −1.0 and 0.5. Set POISSON=ELASTIC to automatically select this parameter value based on the initial elastic part of the material definition. Set POISSON=MATERIAL in an Abaqus/Explicit analysis to cause the thickness direction strain under plane stress conditions to be a function of the membrane strains and the in-plane material properties. In Abaqus/Standard the default is POISSON=0.5; in Abaqus/Explicit the default is POISSON=MATERIAL.

Abaqus User's Manual

In the figure above with reaction force vs displacement, I also included two closed-form calculated curves that match the two groups. I used the following julia code to generate the graph:

# Run in REPL using: include("file.jl")
using LinearAlgebra, Plots, CSV
pyplot()
data1 = CSV.read("Tension_Abaqus_Standard_C3D8_LE.data", delim=' ', ignorerepeated=true, ignoreemptylines=true)
plot(data1[:,6], data1[:,4], label="Abaqus/Standard C3D8", linewidth=2.0, linecolor=:blue, linestyle=:dash)

data2 = CSV.read("Tension_Abaqus_Standard_S4_LE.data", delim=' ', ignorerepeated=true, ignoreemptylines=true)
plot!(data2[:,5], data2[:,3], label="Abaqus/Standard S4", linewidth=2.0, linecolor=:red)

data3 = CSV.read("Tension_Abaqus_Explicit_S4_LE.data", delim=' ', ignorerepeated=true, ignoreemptylines=true)
plot!(data3[:,6], data3[:,4], label="Abaqus/Explicit S4", linewidth=2.0, linecolor=:green)

# closed-form calculation
E = 1.0
nu = 0.4
A0 = 0.01
L0 = 1.0
disp = range(0.0, stop=1.0, length=10)
lambda = (L0.+disp) ./ L0
strain_true = log.(lambda)
stress_true = E * strain_true
strain_transverse = -nu .* strain_true
lambda_transverse = exp.(strain_transverse)
A = lambda_transverse.^2 .* A0
RF = A .* stress_true
plot!(disp, RF, label="Closed-Form Analytical (E=1, nu=0.4)", linewidth=2.0, linecolor=:black, linestyle=:dot)

strain_thickness = -0.5 .* strain_true
lambda_thickness = exp.(strain_thickness)
A = lambda_thickness.^2 .* A0
RF = A .* stress_true
plot!(disp, RF, label="Closed-Form Analytical (E=1, nu=0.5)", linewidth=2.0, linecolor=:cyan, linestyle=:dot)

plot!(size=(800,600), legend=:bottomright, framestyle=:box, tickfontsize=14, guidefontsize=16,
xlims=(0.0, 1.0), ylims=(0, 0.005), legendfontsize=8, xlabel="Displacement (mm)", ylabel="Reaction Force (N)")
savefig("plot_U1_RF1.png")

This example shows that the default behavior for Abaqus/Standard is to conserve volume (nu=0.5) in the through-thickness direction, and the default behavior of Abaqus/Explicit is to calculate the through-thickness Poisson’s ratio using the actual material model. It is quite interesting that the default behaviors is different.

PolyUMod Results

The material models in the PolyUMod library have been coded to support shell elements in a different way than what is used in Abaqus. In Abaqus, the through-thickness strain that gives an out-of-plane stress of zero is searched for at each integration point and each point in time during a simulation. In PolyUMod, shell elements, membrane elements, and plane stress elements have been formulated so that the out of plane stress is automatically zero. This way it is not necessary to search for the through thickness strain. Note that the price for his computationally nice approach is that each PolyUMod material model have two implementations: one for 3D-type elements, and one for plane-stress type elements. And the predicted stress strain response for these two element classes are slightly different.

Also note that when using a PolyUMod material model with Abaqus/Standard, there is no way for the material model to inform Abaqus about the through-thickness response. All of that is managed by Abaqus/Standard. This is a limitation of the UMAT interface that is provide by Abaqus.

When using a PolyUMod material model with a Abaqus/Explicit, the material model needs to return the calculated through thickness strain. This strain is calculated from the in-plane strain together with PolyUMod Global Variable 5 (TWOD_S), which directly specifies the through thickness Poisson’s ratio. The implementation of this is likely quite similar to the Abaqus/Standard implementation when the POISSON parameter is given a numerical value.

Since the PolyUMod material models calculates the stress slightly different for shell, membrane, and plane stress elements, the stress-strain response will be slightly different for these element types compared to traditional 3D elements. This difference is easy to handle when performing a material model calibration using MCalibration, as discussed in the next section.

MCalibration Results

The current stress calculation that is used by PolyUMod for shell elements, membrane elements, and plane stress elements is different than for other elements types (like 3D element, plane strain elements, or axisymmetric elements). The difference between the stress-strain calculations between these two classes of elements types is usually quite small and can most of the time be ignored. If you want to be extra careful, however, you can calibrate the material model differently for shell elements compared to 3D elements. This is easy to do by specifying the loading mode based on the Film option. For example, there is a Uniaxial loading mode and there is a different loading mode called Uniaxial Film (see image below).

Most loading modes that are supported by MCalibration have both a normal mode (for 3D elements) and a Film mode for shell, membrane, and plane stress elements. If you intend to use the calibrated PolyUMod material model with Abaqus/Explicit then you should also specify the through thickness Poisson’s ratio (TWOD_S) variable in the Material Model dialog under the PolyUMod Variables tab (see image below).

Summary

Share on facebook
Facebook
Share on twitter
Twitter
Share on linkedin
LinkedIn

More to explore

1 thought on “Shell Elements in Abaqus, PolyUMod, and MCalibration”

  1. James Woods

    In J2 plasticity plastic flow is incompressible so ABAQUS Standard follows this since shells in standard traditionally were used foremost for metals (using J2 plasticity) like deep drawing etc.

Leave a Comment