<!-- source-page: 421 -->

# Small-strain shell elements

In Abaqus/Standard the three-dimensional “thick” and “thin” element types STRI3, S4R5, STRI65, S8R, S8RT, S8R5, and S9R5 provide for arbitrarily large rotations but only small strains. The change in thickness with deformation is ignored in these elements.

In Abaqus/Explicit element types S3RS, S4RS, and S4RSW are provided for shell problems with small membrane strains and arbitrarily large rotations. Many impact dynamics analyses fall within this class of problems, including those of shell structures undergoing large-scale buckling behavior but relatively small amounts of membrane stretching and compression. Although solution accuracy may degrade as membrane strains become large, the small-strain shell elements in Abaqus/Explicit provide a computationally efficient alternative to the finite-membrane-strain elements for appropriate applications. The underlying formulation is described in “Small-strain shell elements in Abaqus/Explicit,” Section 3.6.6 of the Abaqus Theory Guide.

# Change of shell thickness

Thickness change is considered only in geometrically nonlinear analyses. For conventional shells, stress in the thickness direction is zero and the strain results only from the Poisson’s effect. For continuum shells, the stress in the thickness direction may not be zero and may cause additional strain beyond that due to Poisson’s effect. The thickness strain due to Poisson’s effect is referred as the “Poisson strain,” and any additional strain beyond the “Poisson strain” is referred to as the “effective thickness strain.”

For shell elements in Abaqus/Explicit defined by integrating the section during the analysis, the Poisson strain is calculated by enforcing the plane stress condition either at the individual material points in the section and then integrating the Poisson strain from these material points, or at the integration station for the whole section using a “section Poisson’s ratio.” For shell elements in Abaqus/Standard only the section Poisson’s ratio method is available. For shell elements defined by general shell sections, only the section Poisson’s ratio method is applicable.

See “Defining the Poisson strain in shell elements in the thickness direction” in “Using a shell section integrated during the analysis to define the section behavior,” Section 29.6.5, and “Defining the Poisson strain in shell elements in the thickness direction” in “Using a general shell section to define the section behavior,” Section 29.6.6, for details.

# Thickness direction stress in continuum shell elements

The thickness direction stress is computed by penalizing the effective thickness strain with a constant “thickness modulus.” The thickness modulus used for a single layer shell element with an elastic or elastic-plastic material is twice the in-plane elastic shear modulus. In the case of a composite shell with each layer either an elastic or elastic-plastic material, the thickness modulus is computed as the thicknessweighted harmonic mean of the contributions from the individual layers:

$$
1 / E _ {e f f} = \sum_ {i} ^ {n} r _ {i} / E _ {e f f} ^ {i},
$$

<!-- source-page: 422 -->

where $E _ { e f f }$ is the thickness modulus, is the layer index, is the number of layers, $r _ { i }$ is the relative thickness of layer $( 0 < r _ { i } < 1 )$ , and $E _ { e f f } ^ { i }$ is twice the initial in-plane elastic shear modulus based on the material definition for layer in the initial configuration.

See “Defining the thickness modulus in continuum shell elements” in “Using a shell section integrated during the analysis to define the section behavior,” Section 29.6.5, and “Defining the thickness modulus in continuum shell elements” in “Using a general shell section to define the section behavior,” Section 29.6.6, for details.

# Five degree of freedom shells versus six degree of freedom shells

Two types of three-dimensional conventional shell elements are provided in Abaqus/Standard: ones that use five degrees of freedom (three displacement components and two in-surface rotation components) where possible and ones that use six degrees of freedom (three displacement components and three rotation components) at all nodes.

The elements that use five degrees of freedom (S4R5, STRI65, S8R5, S9R5) can be more economical. However, they are available only as “thin” shells (they cannot be used as “thick” shells) and cannot be used for finite-strain applications (although they model large rotations with small strains accurately). In addition, output for the five degree of freedom shell elements is restricted as follows:

• At nodes that use the two in-surface rotation components, the values of these in-surface rotations are not available for output.   
• When output variable NFORC is requested, moments corresponding to the in-surface rotations are not available for output.

When five degree of freedom shell elements are used, Abaqus/Standard will automatically switch to using three global rotation components at any node that:

• has kinematic boundary conditions applied to rotational degrees of freedom,   
• is used in a multi-point constraint (“General multi-point constraints,” Section 35.2.2) that involves rotational degrees of freedom,   
• is shared with a beam element or a shell element that uses the three global rotation components at all nodes,   
• is on a fold line in the shell (that is, on a line where shells with different surface normals come together), or   
• is loaded with moments.

In all elements that use three global rotation components at all nodes (whether activated as described above or always present), a singularity exists at any node where the surface is assumed to be continuously curved: three rotation components are used, but only two are actively associated with stiffness. A small stiffness is associated with the rotation about the normal to avoid this difficulty. The default stiffness values used are sufficiently small such that the artificial energy content is negligible. In some rare cases this stiffness may need to be altered. You can define a scaling factor for this stiffness, as described in “Using a shell section integrated during the analysis to define the section behavior,” Section 29.6.5, and “Using a general shell section to define the section behavior,” Section 29.6.6.

<!-- source-page: 423 -->

# Reduced integration

Many shell element types in Abaqus use reduced (lower-order) integration to form the element stiffness. The mass matrix and distributed loadings are still integrated exactly. Reduced integration usually provides more accurate results (provided the elements are not distorted or loaded in in-plane bending) and significantly reduces running time, especially in three dimensions.

When reduced integration is used with first-order (linear) elements, hourglass control is required. Therefore, when using first-order reduced-integration elements, you must check if hourglassing is occurring; if it is, a finer mesh may be required or concentrated loads must be distributed over multiple nodes. The second-order reduced-integration elements available in Abaqus/Standard generally do not have the same difficulty and are recommended in cases when the solution is expected to be smooth. First-order elements are recommended when large strains or very high strain gradients are expected.

# Specifying section controls for shell elements

In Abaqus/Standard you can specify nondefault hourglass control parameters for shell elements. In Abaqus/Explicit you can specify second-order accuracy in the element formulation, nondefault hourglass control parameters for S4R, S4RS, and S4RSW elements, or deactivate the drill constraint for S3RS and S4RS elements. See “Section controls,” Section 27.1.4, for more information.

Input File Usage: Use the following options in Abaqus/Standard:

\*SHELL SECTION or \*SHELL GENERAL SECTION \*HOURGLASS STIFFNESS

Use one of the following options in Abaqus/Explicit:

\*SHELL SECTION, CONTROLS=name \*SHELL GENERAL SECTION, CONTROLS=name

Abaqus/CAE Usage: Mesh module: Mesh→Element Type: Element Controls

# Modeling issues

A number of modeling issues must be considered when using shell elements.

# Using S3/S3R and S3RS elements

Both S3 and S3R refer to the same 3-node triangular shell element. This element is a degenerated version of S4R that is fully compatible with S4R and, in Abaqus/Standard, S4.

Element S3RS, available in Abaqus/Explicit, is a degenerated version of S4RS that is fully compatible with S4RS.

S3/S3R and S3RS provide accurate results in most loading situations. However, because of their constant bending and membrane strain approximations, high mesh refinement may be required to capture pure bending deformations or solutions to problems involving high strain gradients. A consequence of the degenerated element formulation is that the solution changes slightly when the element connectivity is permuted.

<!-- source-page: 424 -->

# Degenerating elements

Element types S4, S4R, S4R5, S4RS, S8R5, and S9R5 can be degenerated to triangles. However, for elements S4 (element S4 degenerated to a triangle may exhibit overly stiff response in membrane deformation), S4R, and S4RS it is recommended that S3R and S3RS be used instead.

The quarter-point technique (moving the midside nodes to the quarter points to give a $1 / \sqrt { r }$ singularity for elastic fracture mechanics applications) can be used with the quadratic element types S8R5 and S9R5 (see “Element definition,” Section 2.2.1). The accuracy of the element is very significantly reduced when it is degenerated to a triangle; therefore, this is not recommended except for special applications, such as fracture.

Element types S8R and S8RT cannot be degenerated to triangles. Element types DS4 and DS8 can be degenerated to triangles, but it is recommended that DS3 and DS6 elements be used instead.

# Modeling with continuum shell elements

Continuum shell elements are similar to continuum solids from a modeling point of view. The element geometries for the SC6R and SC8R elements are a triangular prism and hexahedron, respectively, with displacement degrees of freedom only.

Continuum shell elements must be oriented correctly, since these elements have a thickness direction associated with them. See “Shell elements: overview,” Section 29.6.1, for further details on element connectivity and orientation.

When classical shell structures (structures in which only the midsurface geometry and kinematic constraints are provided) are analyzed, care must be taken that appropriate moments and rotations are specified. For example, a moment may be applied as a force-couple system at the corresponding nodes on the top and bottom faces. A rotation boundary condition may be specified through a kinematic constraint to yield the appropriate displacement boundary conditions on the edge of the continuum shell.

Continuum shell elements can be connected directly to first-order continuum solids without any kinematic transition. An appropriate kinematic transition needs to be provided when conventional shell elements are connected to continuum shell elements to correctly transfer the moment/rotation at the reference surface of a conventional shell. Such a transition can be defined with a shell-to-solid coupling constraint or any other kinematic constraint, such as a surface-based coupling constraint, a multi-point constraint, or a linear constraint equation.

# Using the SC6R element

The SC6R element is a degenerated version of the SC8R element. The SC6R element provides accurate results in most loading situations. However, because of its constant bending and membrane strain approximations, high mesh refinement may be required to capture pure bending deformations or solutions to problems involving high strain gradients.

# Modeling contact with continuum shell elements

Continuum shell elements, SC6R and SC8R, allow two-sided contact with changes in the thickness and are thus suitable for modeling contact.

<!-- source-page: 425 -->

# Stable time increment in Abaqus/Explicit

In Abaqus/Explicit the element stable time increment can be controlled by the continuum shell element thickness, particularly for thin shell applications. This may increase significantly the number of increments taken to complete the analysis when compared to the same problem modeled with conventional shell elements. The small stable time increment size may be mitigated by specifying a lower stiffness in the thickness direction when appropriate.

# Limitations with continuum shell elements

Continuum shell elements cannot be used with the hyperfoam material definitions, nor can they be used with general shell sections where the section stiffness is provided directly.

# Modeling a “sandwich” shell

For a “sandwich” shell, in which parts of the cross-section are made of a softer material (especially when the layers are nonisotropic so that some layers are weak in particular directions), the transverse shear flexibility can be important even when the shell is rather thin. Use of general-purpose shell elements or stacking continuum shell elements is recommended in such cases. See “Shell section behavior,” Section 29.6.4, for a discussion of transverse shear stiffness in shell elements.

# Modeling bending of a thin curved shell in Abaqus/Standard

In Abaqus/Standard curved elements (STRI65, S8R5, S9R5) are preferable for modeling bending of a thin curved shell.

Element type STRI3 is a flat facet element. If this element is used to model bending of a curved shell, a dense mesh may be required to obtain accurate results.

# Modeling buckling of doubly curved shells in Abaqus/Standard

Element type S8R5 may give inaccurate results for buckling problems of doubly curved shells due to the fact that the internally defined center node may not be positioned on the actual shell surface. Element type S9R5 should be used instead.

# Using S8R5 in contact analyses

Element type S8R5 is converted automatically to element type S9R5 if a slave surface in a contact pair is attached to the element.

# Applying moments to S9R5 elements

Moments should not be applied to the center node of S9R5 elements.

# Using S4 elements

Element type S4 is a fully integrated, general-purpose, finite-membrane-strain shell element. The element’s membrane response is treated with an assumed strain formulation that gives accurate solutions to in-plane bending problems, is not sensitive to element distortion, and avoids parasitic locking.

<!-- source-page: 426 -->

Element type S4 does not have hourglass modes in either the membrane or bending response of the element; hence, the element does not require hourglass control. The element has four integration locations per element compared with one integration location for S4R, which makes the element computationally more expensive. S4 is compatible with both S4R and S3R. S4 can be used for problems prone to membrane- or bending-mode hourglassing, in areas where greater solution accuracy is required, or for problems where in-plane bending is expected. In all of these situations S4 will outperform element type S4R. S4 cannot be used with the hyperelastic or hyperfoam material definitions in Abaqus/Standard.

<!-- source-page: 427 -->

# 29.6.3 DEFINING THE INITIAL GEOMETRY OF CONVENTIONAL SHELL ELEMENTS

Products: Abaqus/Standard Abaqus/Explicit Abaqus/CAE

# References

• “Shell elements: overview,” Section 29.6.1   
• “Assigning a section,” Section 12.15.1 of the Abaqus/CAE User’s Guide, in the HTML version of this guide   
• “Assigning shell/membrane normal directions,” Section 12.15.5 of the Abaqus/CAE User’s Guide, in the HTML version of this guide

# Overview

The initial shell geometry:

• is defined by initial normal directions, which can be user-defined or calculated by Abaqus;   
• requires that sufficient mesh refinement be used so that the discretized surface accurately represents the actual surface; and   
• can include an offset of the reference surface from the shell’s midsurface.

# Defining nodal normals

This discussion applies to conventional shell elements only. The normals of a continuum shell element are defined by the position of the top and bottom nodes along the shell corner edge (see “Shell elements: overview,” Section 29.6.1).

Shell normals can be defined by giving the direction cosines of the normal to the surface at all nodes attached to shell elements. These direction cosines can be entered as the fourth, fifth, and sixth coordinates of each node definition or in a user-specified normal definition, as described below; see “Normal definitions at nodes,” Section 2.1.4, for more information. If the user-defined normal differs from the midsurface normal by more than 20°, a warning message is issued to the data (.dat) file. However, if the angle is more than 160°, the direction of the midsurface normal is reversed and no warning message is issued. An additional warning message is issued if the nodal normal deviates more than 10° from the average element normal.

Specifying the same normal at a node for all shell elements attached to the node represents a smooth shell surface at the node. Define a user-specified normal to introduce a fold line.

If the normals are not defined as part of the node definition or by a user-specified normal, Abaqus will calculate the normal using the algorithm given below. Since the only information available for this calculation is the nodal coordinates, it may not define the normal directions accurately. Accurate definition can be important on edges of the model, especially if they are also symmetry planes, or on lines where the curvature of the shell changes discontinuously.

<!-- source-page: 428 -->

The normal direction at a node is needed for temperature input and nodal stress output. The direction is taken from the definitions below for the elements adjacent to the nodes. If this leads to a conflict at a node, the positive normal direction used at that node will be the one defined by the lowest numbered element at the node.

# Calculation of average nodal normals by Abaqus

If the nodal normal is not defined as part of the node definition, element normal directions at the node are calculated for all shell and beam elements for which a user-specified normal is not defined (the “remaining” elements). For shell elements the normal direction is orthogonal to the shell midsurface, as described in “Shell elements: overview,” Section 29.6.1. For beam elements the normal direction is the second cross-section direction, as described in “Beam element cross-section orientation,” Section 29.3.4.

The following algorithm is then used to obtain an average normal (or multiple averaged normals) for the remaining elements that need a normal defined:

1. If a node is connected to more than 30 remaining elements, no averaging occurs and each element is assigned its own normal at the node. The first nodal normal is stored as the normal defined as part of the node definition. Each subsequent normal is stored as a user-specified normal.   
2. If a node is shared by 30 or fewer remaining elements, the normals for all the elements connected to the node are computed. Abaqus takes one of these elements and puts it in a set with all the other elements that have normals within 20° of it. Then:

a. Each element whose normal is within 20° of the added elements is also added to this set (if it is not yet included).   
b. This process is repeated until the set contains for each element in the set all the other elements whose normals are within 20°.   
c. If all the normals in the final set are within 20° of each other, an average normal is computed for all the elements in the set. If any of the normals in the set are more than 20° out of line from even a single other normal in the set, no averaging occurs for elements in the set and a separate normal is stored for each element.   
d. This process is repeated until all the elements connected to the node have had normals computed for them.   
e. The first nodal normal is stored as the normal defined as part of the node definition. Each subsequently generated nodal normal is stored as a user-specified normal.

This algorithm ensures that the nodal averaging scheme has no element order dependence. A simple example illustrating this process is included below.

# Example: shell normal averaging

Consider the three element model in Figure 29.6.3–1. Elements 1, 2, and 3 share a common node, node 10, with no user-specified normal defined.

<!-- source-page: 429 -->

![](images/page-429_56aeece3af84a3f07a0721651ec9537595cfe546d0c513f9d3d79506c165ff57.jpg)

<details>
<summary>radar</summary>

| Vertex | Value |
|---|---|
| 1 | 2 |
| 2 | 3 |
| 3 | 1 |
| 4 | 2 |
| 5 | 3 |
| 6 | 1 |
| 7 | 2 |
| 8 | 3 |
| 9 | 1 |
| 10 | 2 |
| 11 | 3 |
| 12 | 1 |
| 13 | 2 |
| 14 | 3 |
| 15 | 1 |
| 16 | 2 |
| 17 | 3 |
| 18 | 1 |
| 19 | 2 |
| 20 | 3 |
| 21 | 1 |
| 22 | 2 |
| 23 | 3 |
| 24 | 1 |
| 25 | 2 |
| 26 | 3 |
| 27 | 1 |
| 28 | 2 |
| 29 | 3 |
| 30 | 1 |
| 31 | 2 |
| 32 | 3 |
| 33 | 1 |
| 34 | 2 |
| 35 | 3 |
| 36 | 1 |
| 37 | 2 |
| 38 | 3 |
| 39 | 1 |
| 40 | 2 |
| 41 | 3 |
| 42 | 1 |
| 43 | 2 |
| 44 | 3 |
| 45 | 1 |
| 46 | 2 |
| 47 | 3 |
| 48 | 1 |
| 49 | 2 |
| 50 | 3 |
| 51 | 1 |
| 52 | 2 |
| 53 | 3 |
| 54 | 1 |
| 55 | 2 |
| 56 | 3 |
| 57 | 1 |
| 58 | 2 |
| 59 | 3 |
| 60 | 1 |
| 61 | 2 |
| 62 | 3 |
| 63 | 1 |
| 64 | 2 |
| 65 | 3 |
| 66 | 1 |
| 67 | 2 |
| 68 | 3 |
| 69 | 1 |
| 70 | 2 |
| 71 | 3 |
| 72 | 1 |
| 73 | 2 |
| 74 | 3 |
| 75 | 1 |
| 76 | 2 |
| 77 | 3 |
| 78 | 1 |
| 79 | 2 |
| 80 | 3 |
| 81 | 1 |
| 82 | 2 |
| 83 | 3 |
| 84 | 1 |
| 85 | 2 |
| 86 | 3 |
| 87 | 1 |
| 88 | 2 |
| 89 | 3 |
| 90 | 1 |
| 91 | 2 |
| 92 | 3 |
| 93 | 1 |
| 94 | 2 |
| 95 | 3 |
| 96 | 1 |
| 97 | 2 |
| 98 | 3 |
| 99 | 1 |
| 100 | 2 |
</details>

Figure 29.6.3–1 Three element example for nodal averaging algorithm.

In the first scenario, suppose that at node 10 the normal for element 2 is within $2 0 ^ { \circ }$ of both elements 1 and 3, but the normals for elements 1 and 3 are not within $2 0 ^ { \circ }$ of each other. In this case, each element is assigned its own normal: one is stored as part of the node definition and two are stored as user-specified normals.

In the second scenario, suppose that at node 10 the normal for element 2 is within $2 0 ^ { \circ }$ of both elements 1 and 3 and the normals for elements 1 and 3 are within $2 0 ^ { \circ }$ of each other. In this case, a single average normal for elements 1, 2, and 3 would be computed and stored as part of the node definition.

In the last scenario, suppose that at node 10 the normal for element 2 is within $2 0 ^ { \circ }$ of element 1 but the normal of element 3 is not within $2 0 ^ { \circ }$ of either element 1 or 2. In this case, an average normal is computed and stored for elements 1, and 2 and the normal for element 3 is stored by itself: one is stored as part of the node definition and the other is stored as a user-specified normal.

# Meshing concerns

In a coarse mesh this algorithm may introduce fold lines where the shell is smooth, or it may create a smooth shell where there should be a fold if the angle of the fold line is less than $2 0 ^ { \circ }$ . Difficulties in large-displacement shell analysis are sometimes caused by false fold lines introduced by coarse meshing. To model a smooth shell, the mesh should be refined enough to create unique nodal normals. To model plates or shells with fold lines, you should define user-specified normals.

<!-- source-page: 430 -->

# Verifying the normal definitions

Normal definitions can be checked by examining the analysis input file processor output. The direction cosines of the reference normal associated with a node are listed under the NODE DEFINITIONS output in the data (.dat) file. User-specified normals are listed under the NORMAL DEFINITIONS output in the data file.

# Offset: reference surface versus midsurface

This discussion applies to conventional shell elements only. Continuum shell elements define a top and bottom surface around the structural body being modeled. The notion of a shell reference surface is not applicable for these types of elements.

The reference surface for conventional shell elements is defined by the shell’s nodes and normal definitions. When modeling with shell elements, the reference surface is typically coincident with the shell’s midsurface. However, many situations arise in which it is more convenient to define the reference surface as offset from the shell’s midsurface. For example, CAD surfaces usually represent either the top or bottom surface of the shell. In this case it may be easier to define the reference surface to be coincident with the CAD surface and, therefore, offset from the shell’s midsurface.

Shell offsets can also be used to define a more precise surface geometry for contact problems where shell thickness is important. Another situation where the offset from the midsurface may be important is when a shell with continuously varying thickness is modeled. In this case if one surface of the shell is smooth while the other surface is rough, as in some aircraft structures, using the smooth surface as the reference surface, with an offset of half the shell’s thickness from the midsurface, will represent the physical geometry more accurately. The use of the midsurface as the reference surface for this case is much more complicated and may result in an inaccurate model.

You can introduce offsets in the section definitions for both shell sections integrated during the analysis and general shell sections. The offset value is defined as a fraction of the shell thickness measured from the shell’s midsurface to the shell’s reference surface. See “Using a shell section integrated during the analysis to define the section behavior,” Section 29.6.5, and “Using a general shell section to define the section behavior,” Section 29.6.6, for details.

The degrees of freedom for the shell are associated with the reference surface. The element’s area and all kinematic quantities are calculated there. Any loading in the plane of the reference surface will, therefore, cause both membrane forces and bending moments when a nonzero offset value is used. Large offset values for curved shells may also lead to a surface integration error, affecting the stiffness, mass, and rotary inertia for the shell section. For stability purposes Abaqus/Explicit also automatically scales the rotary inertia used for shell elements by a factor proportional to the offset squared, which may result in errors for large offsets. When a large offset from the shell’s midsurface is necessary, use multi-point constraints instead (see “General multi-point constraints,” Section 35.2.2).
