<!-- source-page: 311 -->

# 2.9.1 DISPLAY BODY DEFINITION

Products: Abaqus/Standard Abaqus/Explicit Abaqus/CAE

# References

• \*DISPLAY BODY   
• “Defining display body constraints,” Section 15.15.3 of the Abaqus/CAE User’s Guide, in the HTML version of this guide

# Overview

A display body:

• can be two-dimensional planar, axisymmetric, or three-dimensional;   
• is associated with a part instance and up to three reference nodes, such that the motion of the part instance is governed by the motion of the reference nodes;   
• is used for display purposes only and does not take part in the analysis;   
• can be used to make the analysis more efficient while improving visualization of analysis results; and   
• is especially useful for mechanism or multibody dynamic analyses.

# What is a display body?

A display body is a part instance that is used for display only. None of the nodes or elements of the instance take part in the analysis, but they are still available during postprocessing. The motion of the display body is governed by the motion of the associated reference nodes, if any. It behaves like a rigid body since the relative positions of the nodes and elements of the part instance remain constant throughout a simulation. The nodes and elements of the part instance cannot be used to define prescribed conditions, interactions, constraints, etc. Section properties do not have to be assigned to the elements.

A display body is useful in cases where the physical model is different from the idealized model used for the analysis. An idealized model may be difficult to visualize; it may help to include more details in the model for realistic postprocessing purposes. Display bodies allow this without increasing the analysis time.

Display bodies are especially useful in mechanism or multibody dynamics problems where rigid parts interact with each other via connectors. In such cases a part can be represented by a very simple rigid body and a more complex display body. In this case, the rigid body can be as simple as just a node, along with mass and rotary inertia elements attached to that node.

Display bodies can also be used to model stationary objects that are not involved in the analysis but aid in visualization.

<!-- source-page: 312 -->

# Creating a display body

You must specify the part instance to be made a display body.

Input File Usage: \*DISPLAY BODY, INSTANCE=name

Abaqus/CAE Usage: Interaction module: Create Constraint: Display body: select part instance

# The reference nodes

If the display body is not associated with any reference nodes, it will remain fixed in space during the analysis. However, you can specify that the motion of the display body should be governed by the motion of selected reference nodes. These nodes must belong to another part instance in the assembly. They cannot belong to another display body definition. If you specify only one reference node, the display body will translate and rotate based on the translations and rotations of that node during the analysis. If the reference node has no rotational degrees of freedom, the display body will not rotate during the analysis.

If you specify three reference nodes, the display body will translate and rotate based on the translations of all three nodes. The new position of the part instance at any time will be calculated from the new position and orientation of the coordinate system defined by the three reference nodes: the first node will be the origin, the second will be a point in the x-direction, and the third node will be a point in the X–Y plane. Care should be taken when specifying the three nodes so that they do not become colinear at any stage of the analysis. If this occurs, the position of the part instance may change abruptly through that increment.

Input File Usage: \*DISPLAY BODY, INSTANCE=name

first reference node number, second reference node number,

third reference node number

Abaqus/CAE Usage: Interaction module: Create Constraint: Display body: select part

instance, choose Follow single point or Follow three points,

click Edit, and select the reference points

# Using display bodies with connectors

Display bodies can be used effectively in models containing rigid part instances that interact with each other using connector elements. Such models need both rigid bodies and display bodies. The rigid body should contain any nodes used by connectors, used to define mass and inertia properties, and used to apply loads or boundary conditions. The display body should contain the nodes and elements representing the physical part. Care should be taken to ensure that the nodes in the rigid body are not part of the display body. The reference node of the display body will typically be the same as the rigid body reference node.

Figure 2.9.1–1(a) illustrates a model containing rigid bodies and a display body. Part instance A is included in a display body definition. Figure 2.9.1–1(b) shows the same model without the display body. This model will actually be involved in the analysis. The connector node and reference node form a rigid body that represents the analysis version of part instance A. Both these nodes are assembly-level nodes and are not included in the display body.

<!-- source-page: 313 -->

![](images/page-313_6024a09715a8bde9f8f6d53a2f3d31e56b693d615abf98c51c49dd5273e302a5.jpg)  
Figure 2.9.1–1 Example of a display body.

# Input file template

The following input shows how display bodies can be used in a model with rigid part instances and connectors:

```txt
*ASSEMBLY
...
*INSTANCE, NAME=INST1
...
*END INSTANCE
*NODE, NSET=INST1-REFNODE
1001, -10, 0, 0
*NODE, NSET=INST1-CONNECTOR-NODE
1002, -5, -5, 0
*RIGID BODY, TIE NSET=INST1-CONNECTOR-NODE,
REF NODE=INST1-REFNODE
*DISPLAY BODY, INSTANCE=INST1
1001
...
*END ASSEMBLY 
```

<!-- source-page: 314 -->

<!-- source-page: 315 -->

# 2.10 Assembly definition

• “Defining an assembly,” Section 2.10.1

<!-- source-page: 316 -->

<!-- source-page: 317 -->

# 2.10.1 DEFINING AN ASSEMBLY

Products: Abaqus/Standard Abaqus/Explicit

# References

• \*ASSEMBLY   
• \*INSTANCE   
• \*PART

# Overview

A finite element model in Abaqus can be defined as an assembly of part instances. The organization of such a model:

• is consistent with models generated by Abaqus/CAE and displayed in the Visualization module (Abaqus/Viewer); and   
• allows reuse of part definitions, which is valuable for creating large, complex models.

By default, input files written by Abaqus/CAE are written in terms of an assembly of part instances. For input files not written by Abaqus/CAE, the use of part and assembly definitions in the input file is currently optional. However, since the Visualization module displays results in terms of an assembly of part instances, an assembly and at least one part instance will be created automatically by the analysis input file processor if they are not defined in the input file.

# Introduction

A physical model is typically created by assembling various components. The assembly interface in Abaqus allows analysts to create a finite element mesh using an organizational scheme that parallels the physical assembly. In Abaqus the components that are assembled together are called part instances. This section explains how to organize an Abaqus finite element model in terms of an assembly of part instances.

The mesh is created by defining parts, then assembling instances of each part. Each part can be used (instanced) one or more times, and each part instance has its own position within the assembly. This organization of the model definition matches the way models are created in Abaqus/CAE, where the assembly can be created interactively or imported from an input file (see the Abaqus/CAE User’s Guide).

# Terminology

# Assembly

An assembly is a collection of positioned part instances. An analysis is conducted by defining boundary conditions, constraints, interactions, and a loading history for the assembly.

<!-- source-page: 318 -->

# Part

A part is a finite element idealization of an object. Parts are the building blocks of an assembly and can be either rigid or deformable. Parts are reusable; they can be instanced multiple times in the assembly. Parts are not analyzed directly; a part is like a blueprint for its instances.

# Part instance

A part instance is a usage of a part within the assembly. All characteristics (such as mesh and section definitions) defined for a part become characteristics for each instance of that part—they are inherited by the part instances. Each part instance is positioned independently within the assembly.

# Example

A hinge can be modeled using two flanges and a pin, as shown in Figure 2.10.1–1. The flange geometry is defined by creating a part, which is instanced twice inside the hinge assembly. Another part, the pin, is created and instanced once. The pin is modeled as a rigid body created from an analytical surface (see “Analytical rigid surface definition,” Section 2.3.4).

![](images/page-318_e4caeec0e32ddbd166054576d96f015c7200f9c403910cd02c90db0933e38bfb.jpg)

<details>
<summary>text_image</summary>

Part instance Flange-1
Part instance Flange-2
Ref Pt
Part instance Pin-1
</details>

Figure 2.10.1–1 The hinge assembly.

This hinge example is used throughout this section to illustrate the keyword interface for parts and assemblies. This example is also used to illustrate the interactive assembly process (see Getting Started with Abaqus/CAE).

<!-- source-page: 319 -->

Everything defined within a part, instance, or the assembly is local to that part, instance, or the assembly. This means that node/element identifiers and names (like set and surface names) need not be unique throughout a model; they need only be unique within the part, instance, or assembly where they are being defined (see “Viewing part and assembly information in the data file” in “Output,” Section 4.1.1). Names should not use an underscore to join part instance names to element set, node set, orientation names, or distribution names because the names may conflict with internal names used by Abaqus.

For example, consider Figure 2.10.1–2. In this model the assembly (Hinge) contains three part instances (Flange-1, Flange-2, and Pin-1). Multiple sets named top can be defined: in this case one is defined within the assembly and one is defined within each of the Flange part instances. The set name top can be reused, and each set named top is independent from the others.

![](images/page-319_7ea12cb298da2a2d15012df71550a28846dafdbbeacb7ddc82ff649270536751.jpg)

<details>
<summary>flowchart</summary>

```mermaid
graph TD
    A["● assembly"] --> B["● Hinge"]
    C["● part instance"] --> B
    B --> D["Flange-1"]
    B --> E["Pin-1"]
    B --> F["Flange-2"]
    D --> G["set: top"]
    E --> H["set: top"]
    F --> I["set: top"]
```
</details>

Figure 2.10.1–2 The organization of the Hinge assembly.

# Input File Usage:

Use the following options to begin and end each part, instance, and assembly definition:

\*PART/\*END PART   
\*INSTANCE/\*END INSTANCE  
\*ASSEMBLY/\*END ASSEMBLY

If any one of these options appears in an input file, they must all appear except when you import a part instance from a previous analysis; in this case \*PART and \*END PART are not required. The model must be consistently defined as an assembly of part instances.

# Defining a part

A part definition must appear outside the assembly definition. Multiple parts can be defined in a model; each part must have a unique name.

# Input File Usage:

Use the following options to define a part:

\*PART, NAME=PartName   
Node, element, section, set, and surface definitions   
\*END PART

<!-- source-page: 320 -->

# Defining part instances

A part instance definition must appear within the assembly definition. If the part instance is not imported from a previous analysis, each part instance must have a unique name and refer to a part name. A part instance name of Assembly is not allowed. In addition, you can specify data that are used to position the instance within the assembly. Give a translation and rotation for the part instance relative to the origin of the assembly (global) coordinate system.

If the part instance is to be imported from a previous analysis, each part instance must specify the name of the instance to be imported. For more information on defining part instances for use with the import capability, see “Transferring results between Abaqus analyses: overview,” Section 9.2.1.

Additional sets and surfaces can be defined at the instance level, as explained later in this section.

Input File Usage: Use the following options to instance a part that is not imported from a previous analysis:

\*INSTANCE, NAME=InstanceName, PART=PartName

<positioning data>

Additional set and surface definitions (optional)

\*END INSTANCE

Repeat these options, each time referring to the same part name, to instance a part multiple times.

Use the following options to import a part instance from a previous analysis:

\*INSTANCE, INSTANCE=instance-name

Additional set and surface definitions (optional)

\*IMPORT

\*END INSTANCE

# Defining the assembly

Only one assembly can be defined in a model. All part instance definitions must appear within the assembly definition.

Sets and surfaces can be defined at the assembly level by including the appropriate definitions within the assembly definition.

Input File Usage: Use the following options to create an assembly:

\*ASSEMBLY, NAME=name

Part instance definitions

Set and surface definitions

Connector and constraint definitions

Rigid body definitions

\*END ASSEMBLY

# Example

The hinge assembly shown in Figure 2.10.1–1 can be defined using the following syntax in the input file:
