<!-- source-page: 331 -->

<table><tr><td>Example 2</td><td>Notes</td></tr><tr><td>*INSTANCE, NAME=I3, PART=PartC error</td><td>The mesh and section must be defined for each instance since the part is not meshed.</td></tr><tr><td>*END INSTANCE</td><td></td></tr><tr><td>*END ASSEMBLY</td><td></td></tr></table>

# Coordinate system definitions

Abaqus provides several methods for defining local coordinate systems.

# Nodal coordinate systems

You can define nodal coordinates in a local coordinate system (see “Specifying a local coordinate system in which to define nodes” in “Node definition,” Section 2.1.1). The coordinate system can be defined within a part definition to define the nodes in that part. The nodal coordinate system definition remains in effect until another nodal coordinate system is defined within the same level or until the level ends.

# Nodal transformations

A nodal transformation is used for applying loads and boundary conditions (see “Transformed coordinate systems,” Section 2.1.5). It can be defined at the part or assembly level to define a local coordinate system for application of loads and boundary conditions or for the definition of linear constraint equations.

# User-defined orientations

A user-defined orientation is used for defining material properties, coupling, connectors, and rebar (see “Orientations,” Section 2.2.5). It can be defined at the part level for reference from a section, connector, rebar, or coupling definition. An orientation definition can also be used at the assembly level for reference from a connector or coupling definition.

# Distributions

Distributions can be used to specify arbitrary spatial variations of local coordinate systems for continuum and shell elements (see “Orientations,” Section 2.2.5). A distribution used by an orientation should be defined at the level in which the orientation is defined.

# Normal definitions at nodes

Normals can be defined at nodes as part of the node definition for beam, pipe, and shell elements or with a user-specified normal definition (see “Normal definitions at nodes,” Section 2.1.4). These normals can be defined at the part or assembly level.

A local coordinate system defined for a part using any of these methods is inherited by all instances of the part.

<!-- source-page: 332 -->

# Translating and rotating a part instance

The assembly’s coordinate system is the global coordinate system. You can position part instances within the assembly by giving a translation and/or rotation relative to the global origin. Specify a translation by giving a translation vector. Specify a rotation by giving two points, a and b, to define a rotation axis plus a right-handed angular rotation around that axis.

Local coordinate systems defined within a part or part instance will be translated and rotated according to the specified positioning data, as shown in Figure 2.10.1–5. (In this figure details such as element and section definitions are omitted for clarity.) Results given in a local coordinate system are output in the transformed local system. Equations will also be translated and rotated according to the positioning data for an instance. All data within a part (or part instance) definition are defined relative to the part’s local coordinate system; positioning data are applied to a part instance after everything within that instance is defined.

# Limitations

The following capabilities are not supported in a model defined in terms of an assembly of part instances:

• “Mapping a set of nodes from one coordinate system to another” in “Node definition,” Section 2.1.1   
• “Using auxiliary analyses to generate shape variations” in “Parametric shape variation,” Section 2.1.2   
• “Symmetric model generation,” Section 10.4.1   
• “Transferring results from a symmetric mesh or a partial three-dimensional mesh to a full threedimensional mesh,” Section 10.4.2   
• “Reading the element matrices from an Abaqus/Standard results file” in “User-defined elements,” Section 32.17.1

The substructure library is not organized in terms of an assembly of part instances, so substructures cannot be generated from models that have an assembly defined. None of the substructure options are supported in models that have an assembly defined.

# Input file template

This template shows an input file that is written in terms of parts and assemblies with the part instances defined in this analysis. For templates that show how to import a part instance from a previous analysis to transfer model data and results, see “Transferring results between Abaqus/Explicit and Abaqus/Standard,” Section 9.2.2, and “Transferring results from one Abaqus/Standard analysis to another,” Section 9.2.3.

```txt
*HEADING
*PART, NAME=Part-1
Node, element, section, set, and surface definitions
Connector and constraint definitions
*END PART
*PART, NAME=Part-2 
```

<!-- source-page: 333 -->

![](images/page-333_eab35c97f8a054f6a5ed465f1b55b028c3c5af642ae9a504acee8e02aa485e74.jpg)

<details>
<summary>flowchart</summary>

```mermaid
graph TD
    A["*Part, Name=P"] --> B["Local coordinate system defined relative to part coordinate system"]
    C["*System"] --> B
    D["*Node"] --> E["Nodes defined in local coordinate system"]
    F["*End part"] --> E
    G["*Part, Name=Q"] --> H["Local coordinate system only applies within this part definition"]
    I["*Node"] --> H
    J["*End part"] --> H
```
</details>

![](images/page-333_24ff84e3bd6b5b228bc898723696faaaff0061efc783e7a5dfb490b1eae65821.jpg)

<details>
<summary>flowchart</summary>

```mermaid
graph TD
    A["*Assembly, Name=Assembly-1"] --> B["*Instance, Name=Instance-1, Part=Q"]
    B --> C["<positioning data>"]
    C --> D["*End Instance"]
    D --> E["*Instance, Name=Instance-2, Part=P"]
    E --> F["<positioning data>"]
    F --> G["*End Instance"]
    G --> H["*Instance, Name=Instance-3, Part=P"]
    H --> I["<positioning data>"]
    I --> J["*End Instance"]
    J --> K["*End assembly"]
    B --> L["Instances positioned relative to global coordinate system"]
    L --> M["<positioning data>"]
    M --> N["*End Instance"]
    N --> O["*End assembly"]
```
</details>

![](images/page-333_e1605e468db5b3ae6ee596191990003308bc78acb8ab38e931289a63eec19123.jpg)

<details>
<summary>flowchart</summary>

```mermaid
graph TD
    A["Instance-1"] --> B["Instance-2"]
    B --> C["Instance-3"]
    style A fill:#f9f,stroke:#333
    style B fill:#ccf,stroke:#333
    style C fill:#cfc,stroke:#333
```
</details>

Assembly-1 coordinate system

![](images/page-333_4dc303cdf94ff0e4ce40f1ea1484577727bbb0b71c8c77040f2f8e3614a01201.jpg)

<details>
<summary>text_image</summary>

- - - - - Position given relative to the assembly (global) coordinate system (defined by *INSTANCE)
- - - - - Part-local coordinate system (defined by *NORMAL, *ORIENTATION, *SYSTEM, or *TRANSFORM)
</details>

Figure 2.10.1–5 Defining local coordinate systems.

<!-- source-page: 334 -->

```txt
**The instance is meshed, so the part definition is empty
*END PART
*MATERIAL, NAME=mat1
Suboptions and data lines to define this material
*ASSEMBLY, NAME=Assembly-1
*INSTANCE, NAME=i1, PART=Part-1
    <positioning data>
    Additional set and surface definitions (optional)
*END INSTANCE
*INSTANCE, NAME=i2, PART=Part-2
    <positioning data>
    Node, element, section, set, and surface definitions
    Connector and constraint definitions
*END INSTANCE
Assembly-level set and surface definitions
Assembly-level connectors and constraints
Assembly-level reference node definitions
Assembly-level rigid body definitions
*END ASSEMBLY
*MATERIAL, NAME=mat2
Suboptions and data lines to define this material
*AMPLITUDE
*INITIAL CONDITIONS
*BOUNDARY
Zero-valued boundary conditions
*PHYSICAL CONSTANTS
*CONNECTOR BEHAVIOR
Suboptions and data lines to define this connector behavior
Interaction and interaction property definitions in Abaqus/Standard or Abaqus/Explicit
*STEP
Loads and boundary conditions
Predefined field definitions
Output requests
Contact interaction definitions in Abaqus/Explicit
*END STEP 
```

<!-- source-page: 335 -->

# 2.11 Matrix definition

• “Defining matrices,” Section 2.11.1

<!-- source-page: 336 -->

<!-- source-page: 337 -->

# 2.11.1 DEFINING MATRICES

# Product: Abaqus/Standard

# References

• “Generating matrices,” Section 10.3.1   
• \*MATRIX ASSEMBLE   
• \*MATRIX GENERATE   
• \*MATRIX INPUT   
• \*MATRIX OUTPUT

# Overview

# A matrix:

• can be used to represent stiffness, mass, viscous damping, or structural damping for a part of the model or for the entire model;   
• is defined by giving it a unique name and by specifying matrix data, which may be scaled;   
• can be symmetric or unsymmetric;   
• can be given in text format in lower triangular, upper triangular, or square form or read from binary .sim files generated by the matrix generation procedure;   
• can be used to provide linear elastic response with large translations but not large rotations;   
• can be used in static and natural frequency extraction procedures;   
• can be used in matrix generation and substructure generation procedures;   
• can be used in transient modal dynamics, mode-based steady-state dynamics, subspace-based steady-state dynamics, random response, response spectrum, and complex eigenvalue extraction procedures that use the SIM architecture;   
• can have loads, boundary conditions, and constraints applied directly to any matrix nodal degrees of freedom;   
• can be used in submodeling analysis; and   
• cannot be used in direct steady-state dynamic or mode-based analyses that do not use the SIM architecture.

# What is a matrix in Abaqus/Standard?

Designing complex models of structures like automobiles typically involves subcontracting the work on various parts. When the entire model has to be put together, information about the parts needs to be exchanged between different vendors. Often, to avoid the exchange of proprietary information, this information is exchanged in terms of matrices representing the stiffness, mass, and damping for each

<!-- source-page: 338 -->

part. During an analysis these matrices are added to the corresponding global finite element matrices to complete the assembly of the entire model.

Abaqus/Standard provides the capability to input stiffness, mass, viscous damping, and structural damping matrices directly. You can define as many different matrices as are necessary to build the model.

# Including matrices in a model

You must assign a name to the matrix to include it in the matrix usage model.

Input File Usage: \*MATRIX INPUT, NAME=name

# Specifying a matrix type

For matrices given in text format, you can specify the matrix type as symmetric (default) or unsymmetric. If symmetric, it can be entered as a lower triangular, upper triangular, or square matrix.

For matrices read from a .sim file, the matrix type is automatically set according to the matrix data stored on the SIM database.

Input File Usage: Use one of the following options to specify the type for matrices given in text format:

\*MATRIX INPUT, NAME=name, TYPE=SYMMETRIC

\*MATRIX INPUT, NAME=name, TYPE=UNSYMMETRIC

# Scaling the matrix data

You can define a multiplication scale factor for all matrix entries.

Input File Usage: \*MATRIX INPUT, NAME=name, SCALE FACTOR=sval

# Providing matrix data directly

You can specify data directly to define a symmetric matrix in lower triangular, upper triangular, or square format. For a square matrix to be symmetric, corresponding entries above and below the diagonal must have exactly the same values. You can specify data directly to define an unsymmetric matrix by providing data for each matrix entry.

Input File Usage: \*MATRIX INPUT

row node label, degree of freedom for row node, column node label, degree of freedom for column node, matrix entry

Repeat this data line to specify data for each matrix entry.

# Reading the matrix data in text format from an alternate file

Matrix data in text format can be contained in an alternate file. Typically, an alternate file is used for large matrices. To ensure acceptable performance, the data lines in the alternate file are read without extensive checking for data format. You should make sure that the data entries are specified in the proper format without any comments or blank lines. Matrix data output in text format can be generated in the matrix generation procedure (see “Output” in “Generating matrices,” Section 10.3.1).

Input File Usage: \*MATRIX INPUT, NAME=name, INPUT=input\_file\_name

<!-- source-page: 339 -->

# Reading the matrix data from the SIM database

Matrix data in binary format can be read from the .sim file generated by the matrix generation procedure (see “Introduction” in “Generating matrices,” Section 10.3.1). The .sim file can contain stiffness, mass, viscous damping, and structural damping matrices. You specify each matrix to be read from the .sim file.

Input File Usage: Use the following options:
*MATRIX INPUT, NAME=stif_name, INPUT=sim_file_name, MATRIX=STIFFNESS
*MATRIX INPUT, NAME=mass_name, INPUT=sim_file_name, MATRIX=MASS
*MATRIX INPUT, NAME=dmpv_name, INPUT=sim_file_name, MATRIX=VISCOUS DAMPING
*MATRIX INPUT, NAME=dmps_name, INPUT=sim_file_name, MATRIX=STRUCTURAL DAMPING

# Defining the stiffness, mass, and damping with matrices included in a model

You can assemble the stiffness, mass, viscous damping, and structural damping matrices that you have specified into the corresponding global finite element matrices for the model. Many matrices with different names can be defined and assembled.

Input File Usage: Use the following option to assemble matrices generated from the same original model:
*MATRIX ASSEMBLE, STIFFNESS=stif_name, MASS=mass_name, VISCOUS DAMPING=dmpv_name, STRUCTURAL DAMPING=dmps_name
To assemble matrices generated from different original models, repeat the *MATRIX ASSEMBLE option for each model.

# Connecting a part of a model represented by matrices

A part of the model represented by user-defined matrices is connected to other parts and finite elements through shared nodes. You must define these nodes directly in the model (see “Node definition,” Section 2.1.1). In addition, there may be nodes that are used only by matrices but that are not shared. You do not need to define nodes that are not shared and have no loads, boundary conditions, or constraints associated with them; these nodes will be defined for you and placed at the origin of the global coordinate system.

Input File Usage: Use the following option to define the shared nodes directly: *NODE

<!-- source-page: 340 -->

# Remapping user-defined nodes in assembled matrices

The nodes defined in the assembled matrices can be remapped (renamed) to different node labels in the matrix usage model. You must define all the new node labels in the matrix usage model, create a node set from them, and specify this node set when assembling the matrices. The size of the node set and the order of the nodes in the set must fully correspond to the combined set of nodes of all the matrices that are assembled. The matrix nodes are assumed to be sorted in ascending order of their original labels that were defined at generation or specified in the matrix data.

Input File Usage: Use the following option to create a node set for the matrix nodes:
*NSET, NSET=nset_name, UNSORTED
Use the following option to assemble matrices with node remapping:
*MATRIX ASSEMBLE, STIFFNESS=stif_name, MASS=mass_name, VISCOUS DAMPING=dmpv_name,
STRUCTURAL DAMPING=dmps_name, NSET=nset_name

# Multiple instantiation of matrices

With the node remapping feature, the same matrix can be used multiple times in the matrix usage model. You define the matrix once and assemble it several times, specifying the relevant node sets for remapping.

Input File Usage: *MATRIX INPUT, NAME=name
*MATRIX ASSEMBLE, STIFFNESS=name
*MATRIX ASSEMBLE, STIFFNESS=name, NSET=nset1_name
*MATRIX ASSEMBLE, STIFFNESS=name, NSET=nset2_name

# Internal nodes in matrix data

Internal nodes are nodes with internal degrees of freedom associated with them (for example, Lagrange multipliers and generalized displacements) that are created internally by Abaqus/Standard. By definition, user-defined nodes have positive node labels, and internal nodes have negative node labels. You can use the matrix generation procedure to designate some of the user-defined nodes as internal nodes to hide them in the matrix usage model (see “Introduction” in “Generating matrices,” Section 10.3.1).

When using matrix data that contains internal nodes, these nodes are remapped automatically to unique internal node labels in the matrix usage model. For assembled matrices that originate from the same model, the internal nodes are shared. For assembled matrices that originate from different models, the internal nodes are mapped to different internal nodes in the matrix usage model, even if they have the same negative node labels.

# Using matrices in nonlinear analyses

When you use matrices in a nonlinear analysis procedure, nonlinearities are not accounted for. Since the matrix data remain unchanged during the analysis, only linear elastic material behavior can be represented and only large translations can be modeled correctly in a geometrically nonlinear analysis.
