김경종
389 lines
24 KiB
Markdown
389 lines
24 KiB
Markdown
<!-- source-page: 1001 -->
|
||
|
||
where the matrix $\mathbf{K}^{(i)}$ is the stiffness matrix of the ith element and the summation goes over all elements in the assemblage. In an analogous manner the structure mass matrix and load vectors are assembled from the element mass matrices and element load vectors, respectively. In addition to the element stiffness, mass, and load matrices, concentrated stiffnesses, masses, and loads corresponding to specific degrees of freedom can also be added.
|
||
|
||
It should be noted that the element stiffness matrices $\mathbf{K}^{(i)}$ in (12.2) are of the same order as the structure stiffness matrix K. However, considering the internal structure of the matrices $\mathbf{K}^{(i)}$ , nonzero elements are in only those rows and columns that correspond to element degrees of freedom (see Section 4.2). Therefore, in practice, we only need to store the compacted element stiffness matrix, which is of order equal to the number of element degrees of freedom, together with an array that relates to each element degree of freedom the corresponding assemblage degree of freedom. This array is conveniently a connectivity array LM in which entry i gives the equation number that corresponds to the element degree of freedom i.
|
||
|
||
EXAMPLE 12.4: Using the convention for the element degrees of freedom in Fig. 5.4, establish the connectivity arrays defining the assemblage degrees of freedom of the elements in the assemblage in Fig. E12.1.
|
||
|
||
Consider element 1 in Fig. E12.1. For this element, nodes 5, 2, 1, and 4 of the element assemblage correspond to the element nodes 1, 2, 3, and 4, respectively (Fig. 5.4). Using the ID array, the equation numbers corresponding to the nodes 5, 2, 1, and 4 of the element assemblage are obtained, and hence the relation between the column (and row) numbers of the compacted, or local, element stiffness matrix and the global stiffness matrix is as follows:
|
||
|
||
<table><tr><td colspan="9">Corresponding column and row numbers</td></tr><tr><td>For compacted matrix</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td></tr><tr><td>For $\mathbf{K}^{(1)}$ </td><td>3</td><td>4</td><td>0</td><td>0</td><td>0</td><td>0</td><td>1</td><td>2</td></tr></table>
|
||
|
||
The array LM, storing the assemblage degrees of freedom of this element, is therefore
|
||
|
||
$$
|
||
\mathbf {L M} = \left[ \begin{array}{l l l l l l l l} 3 & 4 & 0 & 0 & 0 & 0 & 1 & 2 \end{array} \right]
|
||
$$
|
||
|
||
where a zero means that the corresponding column and row of the compacted element stiffness are ignored and do not enter the global structure stiffness matrix.
|
||
|
||
Similarly, we can obtain the LM arrays that correspond to the elements 2, 3, and 4. We have
|
||
<table><tr><td>for element 2:</td><td>LM = [5 6 0 0 0 0 3 4]</td></tr><tr><td>for element 3:</td><td>LM = [9 10 3 4 1 2 7 8]</td></tr><tr><td>and for element 4:</td><td>LM = [11 12 5 6 3 4 9 10]</td></tr></table>
|
||
|
||
As shown in the example, the connectivity array of an element is determined from the nodal points to which the element is connected and the equation numbers that have been assigned to those nodal points. Once the array LM has been defined, the corresponding element stiffness matrix can be added in compact form to the structure stiffness matrix K, but the process must take due account of the specific storage scheme used for K. As already
|
||
|
||
<!-- source-page: 1002 -->
|
||
|
||
pointed out in Section 2.2, an effective storage scheme for the structure stiffness matrix is to store only the elements below the skyline of the matrix K (i.e., the active columns of K) in a one-dimensional array A. However, together with the active column storage scheme, we also need a specific procedure for addressing the elements of K in A when they are stored as indicated in Section 2.2. Thus, before we are able to proceed with the assemblage of the element stiffness matrices, it is necessary to establish the addresses of the stiffness matrix elements in the one-dimensional array A.
|
||
|
||
Figure 12.2 shows the element pattern of a typical stiffness matrix. Let us derive the storage scheme and addressing procedure that we propose to use, and that are employed with the active column solver discussed in Section 8.2.3. Since the matrix is symmetric, we choose to store and work on only the part above and including the diagonal. However, in addition, we observe that the elements $(i, j)$ of K (i.e., $k_{ij}$ ) are zero for $j > i + m_{K}$ . The
|
||
|
||
|
||
|
||
<details>
|
||
<summary>flowchart</summary>
|
||
|
||
```mermaid
|
||
graph TD
|
||
A["Matrix Matrix A(21) stores k58"] -->|m6 = 3| B["Skyline"]
|
||
B --> C["Matrix Element A(1) to A(21)"]
|
||
C --> D["Array A storing elements of K"]
|
||
D --> E["Matrix Element A(1) to A(21)"]
|
||
E --> F["MaxA"]
|
||
style A fill:#f9f,stroke:#333
|
||
style B fill:#ccf,stroke:#333
|
||
style C fill:#cfc,stroke:#333
|
||
style D fill:#fcc,stroke:#333
|
||
style E fill:#fcf,stroke:#333
|
||
style F fill:#cff,stroke:#333
|
||
```
|
||
</details>
|
||
|
||
Figure 12.2 Storage scheme used for a typical stiffness matrix
|
||
|
||
<!-- source-page: 1003 -->
|
||
|
||
value $m_{\mathbf{K}}$ is known as the half-bandwidth of the matrix. Defining by $m_{i}$ the row number of the first nonzero element in column $i$ (Fig. 12.2), the variables $m_{i}, i = 1, \ldots, n$ , define the skyline of the matrix, and the variables $i - m_{i}$ are the column heights. Furthermore, the half-bandwidth of the stiffness matrix, $m_{\mathbf{K}}$ , equals $\max \{i - m_{i}\}, i = 1, \ldots, n$ ; i.e., $m_{\mathbf{K}}$ is equal to the maximum difference in global degrees of freedom pertaining to any one of the finite elements in the mesh. In many finite element analyses, the column heights vary with $i$ , and it is important that all zero elements outside the skyline not be included in the equation solution (see Section 8.2.3).
|
||
|
||
The columns heights are determined from the connectivity arrays, LM, of the elements; i.e., by evaluating $m_{i}$ , we also obtain the column height $i - m_{i}$ . Consider, as an example, that $m_{10}$ of the stiffness matrix that corresponds to the element assemblage in Fig. E12.1 is required. The LM arrays of the four elements have been given in Example 12.4. We note that only elements 3 and 4 couple into degree of freedom 10, and that the smallest number of degree of freedom in the LM array of these elements is 1; hence, $m_{10} = 1$ and the column height of column 10 is 9.
|
||
|
||
With the column heights of a stiffness matrix defined, we can now store all elements below the skyline of K as a one-dimensional array in A; i.e., the active columns of K including the diagonal elements are stored consecutively in A. Figure 12.2 shows which storage locations the elements of the matrix K given in the figure would take in A. In addition to A, we also define an array MAXA, which stores the addresses of the diagonal elements of K in A; i.e., the address of the ith diagonal element of K, $k_{ii}$ , in A is MAXA(I). Referring to Fig. 12.2, it is noted that MAXA(I) is equal to the sum of the column heights up to the $(i - 1)$ st column plus I. Hence the number of nonzero elements in the ith column of K is equal to MAXA(I + 1) - MAXA(I), and the element addresses are MAXA(I), MAXA(I) + 1, MAXA(I) + 2, $\ldots$ , MAXA(I + 1) - 1. It follows that using this storage scheme of K in A together with the address array MAXA, each element of K in A can be addressed easily.
|
||
|
||
This storage scheme is used in the computer program STAP presented in Section 12.4 and in the equation and eigenvalue solution subroutines in Sections 8.2.3 and 11.6.5. The scheme is quite effective because no elements outside the skyline are stored and processed in the calculations.
|
||
|
||
In the discussion of algorithms for the solution of the equations $\mathbf{KU} = \mathbf{R}$ , where $\mathbf{K}$ , $\mathbf{U}$ , and $\mathbf{R}$ are the stiffness matrix, the displacement vector, and the load vector of the element assemblage, respectively, we pointed out that the active column and other solution procedures require about $\frac{1}{2} nm_{\mathbf{K}}^{2}$ operations, where $n$ is the order of the stiffness matrix, $m_{\mathbf{K}}$ is its half-bandwidth, and we assume constant column heights; i.e., $i - m_{i} = m_{\mathbf{K}}$ for nearly all $i$ . Therefore, it can be important to minimize $m_{\mathbf{K}}$ from considerations of both storage requirements and number of operations. If the column heights vary, a mean or "effective" value for $m_{\mathbf{K}}$ must be used (see Section 8.2.3). In practice we can frequently determine a reasonable nodal point numbering by inspection. However, this nodal point numbering may not be particularly easy to generate, and various automatic schemes are currently used for bandwidth reduction; see Section 8.2.3. Figure 12.3 shows a typical good and a typical bad nodal point numbering.
|
||
|
||
It should be pointed out that in the discussion of the above storage scheme, we implicitly assumed that the entire array A (i.e., the sum of all active columns of the matrix K) does fit into the available high-speed storage of the computer. For instructional purposes
|
||
|
||
<!-- source-page: 1004 -->
|
||
|
||
|
||
|
||
<details>
|
||
<summary>line</summary>
|
||
|
||
| Point | Value |
|
||
|---|---|
|
||
| 1 | 14 |
|
||
| 2 | 21 |
|
||
| 3 | 22 |
|
||
| 4 | 23 |
|
||
| 5 | 24 |
|
||
| 6 | 25 |
|
||
| 7 | 26 |
|
||
| 8 | 27 |
|
||
| 9 | 28 |
|
||
| 10 | 29 |
|
||
| 11 | 30 |
|
||
| 12 | 31 |
|
||
| 13 | 32 |
|
||
| 14 | 33 |
|
||
| 15 | 23 |
|
||
| 16 | 24 |
|
||
| 17 | 25 |
|
||
| 18 | 26 |
|
||
| 19 | 27 |
|
||
| 20 | 28 |
|
||
</details>
|
||
|
||
(a) Bad nodal point numbering, $m_{K} + 1 = 46$
|
||
|
||
|
||
|
||
<details>
|
||
<summary>line</summary>
|
||
|
||
| Node | Value |
|
||
|---|---|
|
||
| 1 | 1 |
|
||
| 2 | 2 |
|
||
| 3 | 3 |
|
||
| 4 | 4 |
|
||
| 5 | 5 |
|
||
| 6 | 6 |
|
||
| 7 | 7 |
|
||
| 8 | 8 |
|
||
| 9 | 9 |
|
||
| 10 | 10 |
|
||
| 11 | 11 |
|
||
| 12 | 12 |
|
||
| 13 | 13 |
|
||
| 14 | 14 |
|
||
| 15 | 15 |
|
||
| 16 | 16 |
|
||
| 17 | 17 |
|
||
| 18 | 18 |
|
||
| 19 | 19 |
|
||
| 20 | 20 |
|
||
| 21 | 21 |
|
||
| 22 | 22 |
|
||
| 23 | 23 |
|
||
| 24 | 24 |
|
||
| 25 | 25 |
|
||
| 26 | 26 |
|
||
| 27 | 27 |
|
||
| 28 | 28 |
|
||
| 29 | 29 |
|
||
| 30 | 30 |
|
||
| 31 | 31 |
|
||
| 32 | 32 |
|
||
| 33 | 33 |
|
||
</details>
|
||
|
||
(b) Good nodal point numbering, $m_{\mathbf{K}} + 1 = 16$
|
||
Figure 12.3 Bad and good nodal point numbering for finite element assemblage
|
||
|
||
it is most appropriate to concentrate on in-core solution, although in practice large systems are solved by storing the matrices in blocks. Considering out-of-core solution, in principle, the same storage scheme is effective as for in-core solutions. The main additional problem is one of program logistics; namely, the individual blocks of the matrices must be stored on backup storage and called into high-speed storage in an effective manner. Specific attention must then be given to minimize the amount of disk writing and reading required in the assemblage. However, once an effective in-core finite element solution has been studied, little difficulty should be encountered in understanding an out-of-core implementation.
|
||
|
||
# 12.3 CALCULATION OF ELEMENT STRESSES
|
||
|
||
In the previous section we described the process of assembling individual finite element matrices into total structure matrices. The next step is the calculation of nodal point displacements using the procedures discussed in Chapters 8 and 9. Once the nodal point displacements have been obtained, element stresses are calculated in the final phase of the analysis.
|
||
|
||
The equations employed in the element stress calculations are (4.11) and (4.12). However, as in the assemblage of the structure matrices, it is again effective to manipulate compacted finite element matrices, i.e., deal only with the nonzero columns of $\mathbf{B}^{(m)}$ in (4.11). Using the implementation described in the previous section, we calculate the element compacted strain-displacement transformation matrix and then extract the element nodal point displacements from the total displacement vector using the LM array of the element. The procedure is implemented in the program STAP described next. Of course, in linear analysis the finite element stresses can be calculated at any desired location by simply establishing the strain-displacement transformation matrix for the point under consideration in the element. In isoparametric finite element analysis we use the procedures given in Chapter 5.
|
||
|
||
<!-- source-page: 1005 -->
|
||
|
||
# 12.4 EXAMPLE PROGRAM STAP
|
||
|
||
Probably the best way of getting familiar with the implementation of finite element analysis is to study an actual computer program that, although simplified in various areas, shows all the important features of more general codes. The following program, STAP (STatic Analysis Program), is a simple computer program for static linear elastic finite element analysis.
|
||
|
||
The main objective in the presentation of the program is to show the overall flow of a typical finite element analysis program, and for this reason only a truss element has been made available in STAP. However, the code can generally be used for one-, two-, and three-dimensional analysis, and additional elements can be added with relative ease. $^{1}$
|
||
|
||
Figure 12.4 shows a flowchart of the program, and Fig. 12.5 gives the storage allocations used during the various program phases. We should note that the elements are processed in element groups. This concept is valuable when implementing the program on parallel processing machines. Next we give the instructions describing the data input to the program.
|
||
|
||
# 12.4.1 Data Input to Computer Program STAP
|
||
|
||
# I. HEADING LINE (20A4)
|
||
|
||
<table><tr><td>Note</td><td>Columns</td><td>Variable</td><td>Entry</td></tr><tr><td>(1)</td><td>1–80</td><td>HED (20)</td><td>Enter the master heading information for use in labeling the output</td></tr></table>
|
||
|
||
# NOTES/
|
||
|
||
1. Begin each new data case with a new heading line. Two blank lines must be input after the last data case.
|
||
|
||
# II. CONTROL LINE (415)
|
||
|
||
<table><tr><td>Note</td><td>Columns</td><td>Variable</td><td>Entry</td></tr><tr><td>(1)</td><td>1-5</td><td>NUMNP</td><td>Total number of nodal points; EQ.0, program stop</td></tr><tr><td>(2)</td><td>6-10</td><td>NUMEG</td><td>Total number of element groups, GT.0</td></tr><tr><td>(3)</td><td>11-15</td><td>NLCASE</td><td>Number of load cases, GT.0</td></tr><tr><td>(4)</td><td>16-20</td><td>MODEX</td><td>Flag indicating solution mode; EQ.0, data check only EQ.1, execution</td></tr></table>
|
||
|
||
# NOTES/
|
||
|
||
1. The total number of nodes (NUMNP) controls the amount of data to be read in Section III. If NUMNP.EQ.0, the program stops.
|
||
|
||
$^{1}$ The program has been tested on a Cray, various engineering workstations, and PCs.
|
||
|
||
<!-- source-page: 1006 -->
|
||
|
||
2. The total number of elements are dealt with in element groups. An element group consists of a convenient collection of elements. Each element group is input as given in Section V. There must be at least one element per element group, and there must be at least one element group.
|
||
3. The number of load cases (NLCASE) gives the number of load vectors for which the displacement and stress solution is sought.
|
||
|
||
|
||
|
||
<details>
|
||
<summary>flowchart</summary>
|
||
|
||
```mermaid
|
||
graph TD
|
||
A["START"] --> B["READ NEXT DATA CASE"]
|
||
B --> C["Read nodal point data (coordinates, boundary conditions) and establish equation numbers in the ID array."]
|
||
C --> D["Calculate and store load vectors for all load cases."]
|
||
D --> E["Read, generate, and store element data. Loop over all element groups."]
|
||
E --> F["Read element group data, and assemble global structure stiffness matrix. Loop over all element groups."]
|
||
F --> G["Calculate L*D*L^T factorization of global stiffness matrix.*"]
|
||
G --> H["FOR EACH LOAD CASE"]
|
||
H --> I["Read load vector and calculate nodal point displacements."]
|
||
I --> J["Read element group data and calculate element stresses. Loop over all element groups."]
|
||
J --> K["END"]
|
||
D --> L["Unit ILOAD"]
|
||
E --> M["Unit IELMNT"]
|
||
G --> N["Unit ILOAD"]
|
||
G --> O["Unit IELMNT"]
|
||
```
|
||
</details>
|
||
|
||
Figure 12.4 Flowchart of program STAP
|
||
|
||
<!-- source-page: 1007 -->
|
||
|
||
|
||
|
||
<details>
|
||
<summary>flowchart</summary>
|
||
|
||
```mermaid
|
||
graph TD
|
||
A["N1 = 1"] --> B["3*NUMNP"]
|
||
B --> C["ID - array"]
|
||
D["N2"] --> E["NUMNP*ITWO"]
|
||
E --> F["X - coordinate array"]
|
||
G["N3"] --> H["NUMNP*ITWO"]
|
||
H --> I["Y - coordinate array"]
|
||
J["N4"] --> K["NUMNP*ITWO"]
|
||
K --> L["Z - coordinate array"]
|
||
M["N5"] --> N["NEQ*ITWO"]
|
||
N --> O["Load vector R"]
|
||
P["N6"] --> Q["NLOAD"]
|
||
Q --> R["NOD"]
|
||
S["N7"] --> T["NLOAD"]
|
||
T --> U["IDIRN"]
|
||
V["N8"] --> W["NLOAD*ITWO"]
|
||
W --> X["FLOAD"]
|
||
R --> Y["Variables to define load vectors"]
|
||
U --> Y
|
||
```
|
||
</details>
|
||
|
||
(a) Input of ID array, nodal point coordinates, and load vectors.
|
||
|
||
|
||
|
||
<details>
|
||
<summary>flowchart</summary>
|
||
|
||
```mermaid
|
||
graph TD
|
||
A["N1 = 1"] --> B["3*NUMNP"]
|
||
C["N2"] --> D["NUMNP*ITWO"]
|
||
E["N3"] --> F["NUMNP*ITWO"]
|
||
G["N4"] --> H["NUMNP*ITWO"]
|
||
I["N5"] --> J["NEQ"]
|
||
K["N6"] --> L["2*NUMMAT*ITWO + 7*NUME + 6*NUME*ITWO"]
|
||
B --> M["ID - array"]
|
||
D --> N["X - coordinate array"]
|
||
F --> O["Y - coordinate array"]
|
||
H --> P["Z - coordinate array"]
|
||
J --> Q["Vector of column heights MHT"]
|
||
L --> R["Element group data (element groups are read in succession)"]
|
||
```
|
||
</details>
|
||
|
||
(b) Element data input
|
||
Figure 12.5 High-speed storage allocation in program STAP.
|
||
|
||
ITWO = 1 in single precision arithmetic.
|
||
|
||
ITWO = 2 in double precision arithmetic.
|
||
|
||
<!-- source-page: 1008 -->
|
||
|
||
|
||
|
||
<details>
|
||
<summary>flowchart</summary>
|
||
|
||
```mermaid
|
||
graph TD
|
||
A["Address N1 = 1"] --> B["Storage 3*NUMNP"]
|
||
C["N2"] --> D["NEQ + 1"]
|
||
E["N3"] --> F["NWK*ITWO"]
|
||
G["N4"] --> H["NEQ*ITWO"]
|
||
I["N5"] --> J["2*NUMMAT*ITWO + 7*NUME + 6*NUME*ITWO"]
|
||
B --> K["ID - array"]
|
||
D --> L["MAXA - array"]
|
||
F --> M["Global structure stiffness matrix K"]
|
||
H --> N["Load vector R and then displacement solution U"]
|
||
J --> O["Element group data (element groups are read in succession)"]
|
||
```
|
||
</details>
|
||
|
||
(c) Assemblage of global structure stiffness; displacement and stress solution phase
|
||
Figure 12.5 (continued)
|
||
|
||
4. The MODEX parameter determines whether the program is to check the data without executing the analysis (i.e., MODEX. EQ. 0) or if the program is to solve the problem (i.e., MODEX. EQ. 1). In the data-check-only mode, the program only reads and prints all data.
|
||
|
||
III. NODAL POINT DATA LINES (415, 3F10.0, 15)
|
||
|
||
<table><tr><td>Note</td><td>Columns</td><td>Variable</td><td>Entry</td></tr><tr><td>(1)</td><td>1-5</td><td>N</td><td>Node (joint) number;GE.1 and LE.NUMNP</td></tr><tr><td rowspan="3">(2)</td><td>6-10</td><td>ID (1, N)</td><td>X—translation boundary code</td></tr><tr><td>11-15</td><td>ID (2, N)</td><td>Y—translation boundary code</td></tr><tr><td>16-20</td><td>ID (3, N)</td><td>Z—translation boundary code</td></tr><tr><td rowspan="3">(3)</td><td>21-30</td><td>X(N)</td><td>X—coordinate</td></tr><tr><td>31-40</td><td>Y(N)</td><td>Y—coordinate</td></tr><tr><td>41-50</td><td>Z(N)</td><td>Z—coordinate</td></tr><tr><td>(4)</td><td>51-55</td><td>KN</td><td>Node number increment for node data generation;EQ.0, no generation</td></tr></table>
|
||
|
||
# NOTES/
|
||
|
||
1. Nodal data must be defined for all (NUMNP) nodes. Node data may be input directly (i.e., each node on its own individual line) or the generation option may be used if
|
||
|
||
<!-- source-page: 1009 -->
|
||
|
||
applicable (see note 4 below). Admissible node numbers range from 1 to the total number of nodes (NUMNP). The last node that is input must be NUMNP.
|
||
|
||
2. Boundary condition codes can be assigned only the following values (M = 1, 2, 3)
|
||
|
||
$$
|
||
\mathbf {I D} (\mathbf {M}, \mathbf {N}) = 0; \quad \text { unspecified (free) displacement }
|
||
$$
|
||
|
||
$$
|
||
\mathrm{ID} (\mathbf {M}, \mathbf {N}) = 1; \quad \text { deleted (fixed) displacement }
|
||
$$
|
||
|
||
An unspecified $[ID(M, N) = 0]$ degree of freedom is free to translate as the solution dictates. Concentrated forces may be applied in this degree of freedom.
|
||
|
||
One system equilibrium equation is established for each unspecified degree of freedom in the model. The total number of equilibrium equations is defined as NEQ and is always less than three times the total number of nodes in the system.
|
||
|
||
Deleted $[ID(M, N) = 1]$ degrees of freedom are removed from the final set of equilibrium equations. Deleted degrees of freedom are used to define fixities (points of external reaction), and any loads applied in these degrees of freedom are ignored by the program.
|
||
|
||
3. The geometric location of each node is specified by its X, Y, and Z coordinates.
|
||
|
||
4. Node lines need not be input in node order sequence; eventually, however, all nodes in the set [1, NUMNP] must be defined. Nodal data for a series of nodes
|
||
|
||
$$
|
||
[ \mathrm{N} _ {1}, \mathrm{N} _ {1} + 1 * \mathrm{KN} _ {1}, \mathrm{N} _ {1} + 2 * \mathrm{KN} _ {1}, \dots , \mathrm{N} _ {2} ]
|
||
$$
|
||
|
||
may be generated from information given on two lines in sequence—
|
||
|
||
$$
|
||
\text { LINE } 1 - \mathrm{N} _ {1}, \mathrm{ID} (1, \mathrm{N} _ {1}), \dots , \mathrm{X} (\mathrm{N} _ {1}), \dots , \mathrm{KN} _ {1}
|
||
$$
|
||
|
||
$$
|
||
\text { LINE } 2 - \mathrm{N} _ {2}, \mathrm{ID} (1, \mathrm{N} _ {2}), \dots , \mathrm{X} (\mathrm{N} _ {2}), \dots , \mathrm{KN} _ {2}
|
||
$$
|
||
|
||
$KN_{1}$ is the node generation parameter given on the first line in the sequence. The first generated node is $N_{1} + 1 * KN_{1}$ ; the second generated node is $N_{1} + 2 * KN_{1}$ ; etc. Generation continues until node number $N_{2} - KN_{1}$ is established. Note that the node difference $N_{2} - N_{1}$ must be evenly divisible by $KN_{1}$ .
|
||
|
||
In the generation the boundary condition codes $[ID(L, J)$ values] of the generated nodes are set equal to those of node $N_{1}$ . The coordinate values of the generated nodes are interpolated linearly.
|
||
|
||
# IV. LOAD DATA LINES
|
||
|
||
Each load case requires the following set of lines. The total number of load cases was defined on the CONTROL LINE (Section II).
|
||
|
||
LINE 1 (215)
|
||
<table><tr><td>Note</td><td>Columns</td><td>Variable</td><td>Entry</td></tr><tr><td>(1)</td><td>1–5</td><td>LL</td><td>Enter the load case number</td></tr><tr><td>(2)</td><td>6–10</td><td>NLOAD</td><td>Enter the number of concentrated loads applied in this load case</td></tr></table>
|
||
|
||
<!-- source-page: 1010 -->
|
||
|
||
# NOTES/
|
||
|
||
1. Load cases must be input in ascending sequence beginning with 1.
|
||
2. The variable NLOAD defines the number of lines to be read next for this load case.
|
||
|
||
NEXT LINES (2I5, F10.0)
|
||
|
||
<table><tr><td>Note</td><td>Columns</td><td>Variable</td><td>Entry</td></tr><tr><td>(1)</td><td>1-5</td><td>NOD</td><td>Node number to which this load is applied;GE.1 and LE.NUMNP</td></tr><tr><td>(2)</td><td>6-10</td><td>IDIRN</td><td>Degree of freedom number for this load component;EQ.1, X-directionEQ.2, Y-directionEQ.3, Z-direction</td></tr><tr><td></td><td>11-20</td><td>FLOAD</td><td>Magnitude of load</td></tr></table>
|
||
|
||
# NOTES/
|
||
|
||
1. For each concentrated load applied in this load case, one line must be supplied.
|
||
2. All loads must be acting into the global X-, Y-, or Z-direction.
|
||
|
||
# V. TRUSS ELEMENTS
|
||
|
||
TRUSS elements are two-node members allowed arbitrary orientation in the X, Y, Z system. The truss transmits axial force only, and in general is a six degree of freedom element (i.e., three global translation components at each end of the member). The following sequence of lines is input for each element group. The total number of element groups (NUMEG) was defined on the CONTROL LINE (Section II).
|
||
|
||
V.1 Element Group Control Line (315)
|
||
|
||
<table><tr><td>Note</td><td>Columns</td><td>Variable</td><td>Entry</td></tr><tr><td></td><td>1-5</td><td>NPAR(1)</td><td>Enter the number 1</td></tr><tr><td>(1)</td><td>6-10</td><td>NPAR(2)</td><td>Number of TRUSS elements in this group;NPAR(2) = NUMEGE.1</td></tr><tr><td>(2)</td><td>11-15</td><td>NPAR(3)</td><td>Number of different sets of material/section properties;NPAR(3) = NUMMATGE.1EQ.0, default set to 1</td></tr></table>
|
||
|
||
# NOTES/
|
||
|
||
1. TRUSS element numbers begin with 1 and end with the total number of elements in this group, NPAR(2). Element data are input in Section V.3.
|
||
2. The variable NPAR(3) defines the number of sets of material/section properties to be read in Section V.2.
|