김경종
604 lines
22 KiB
Markdown
604 lines
22 KiB
Markdown
<!-- source-page: 991 -->
|
||
|
||
```csv
|
||
I=I + 1 SSP00562
|
||
IF (I.LE.NROOT) GO TO 270 SSP00563
|
||
BUPC(L)=BUP(I-1) SSP00564
|
||
290 LM=L SSP00565
|
||
IF (NROOT.EQ.NC) GO TO 300 SSP00566
|
||
295 IF (BUP(I-1).LE.BLO(I)) GO TO 300 SSP00567
|
||
IF (RTOLV(I).GT.RTOL) GO TO 300 SSP00568
|
||
BUPC(L)=BUP(I) SSP00569
|
||
NEIV(L)=NEIV(L) + 1 SSP00570
|
||
NROOT=NROOT + 1 SSP00571
|
||
IF (NROOT.EQ.NC) GO TO 300 SSP00572
|
||
I=I + 1 SSP00573
|
||
GO TO 295 SSP00574
|
||
C SSP00575
|
||
C FIND SHIFT SSP00576
|
||
C SSP00577
|
||
300 WRITE (IOUT,1020) SSP00578
|
||
WRITE (IOUT,1005) (BUPC(I),I=1,LM) SSP00579
|
||
WRITE (IOUT,1030) SSP00580
|
||
WRITE (IOUT,1006) (NEIV(I),I=1,LM) SSP00581
|
||
LL=LM - 1 SSP00582
|
||
IF (LM.EQ.1) GO TO 310 SSP00583
|
||
330 DO 320 I=1,LL SSP00584
|
||
320 NEIV(L)=NEIV(L) + NEIV(I) SSP00585
|
||
L=L - 1 SSP00586
|
||
LL=LL - 1 SSP00587
|
||
IF (L.NE.1) GO TO 330 SSP00588
|
||
310 WRITE (IOUT,1040) SSP00589
|
||
WRITE (IOUT,1006) (NEIV(I),I=1,LM) SSP00590
|
||
L=0 SSP00591
|
||
DO 340 I=1,LM SSP00592
|
||
L=L + 1 SSP00593
|
||
IF (NEIV(I).GE.NROOT) GO TO 350 SSP00594
|
||
340 CONTINUE SSP00595
|
||
350 SHIFT=BUPC(L) SSP00596
|
||
NEI=NEIV(L) SSP00597
|
||
GO TO 900 SSP00598
|
||
C SSP00599
|
||
800 STOP SSP00600
|
||
900 RETURN SSP00601
|
||
C SSP00602
|
||
1005 FORMAT ( ' ',6E22.14) SSP00603
|
||
1006 FORMAT ( ' ',6I22) SSP00604
|
||
1010 FORMAT ( ' *** ERROR *** SOLUTION STOP IN *SCHECK* ',/, SSP00605
|
||
1 ' NO EIGENVALUES FOUND ',/ ) SSP00606
|
||
1020 FORMAT (///,' UPPER BOUNDS ON EIGENVALUE CLUSTERS') SSP00607
|
||
1030 FORMAT (///,' NO. OF EIGENVALUES IN EACH CLUSTER') SSP00608
|
||
1040 FORMAT ( ' NO. OF EIGENVALUES LESS THAN UPPER BOUNDS') SSP00609
|
||
END SSP00610
|
||
SUBROUTINE JACOBI (A,B,X,EIGV,D,N,NWA,RTOL,NSMAX,IFPR,IOUT) SSP00611
|
||
C SSP00612
|
||
C . SSP00613
|
||
C . P R O G R A M . SSP00614
|
||
C . TO SOLVE THE GENERALIZED EIGENPROBLEM USING THE . SSP00615
|
||
C . GENERALIZED JACOBI ITERATION . SSP00616
|
||
C . IMPLICIT DOUBLE PRECISION (A-H,O-Z) SSP00617
|
||
DIMENSION A(NWA),B(NWA),X(N,N),EIGV(N),D(N) SSP00618
|
||
C SSP00619
|
||
C INITIALIZE EIGENVALUE AND EIGENVECTOR MATRICES SSP00620
|
||
C SSP00621
|
||
N1=N + 1 SSP00622
|
||
II=1 SSP00623
|
||
DO 10 I=1,N SSP00624
|
||
IF (A(II).GT.0. .AND. B(II).GT.0.) GO TO 4 SSP00625
|
||
WRITE (IOUT,2020) II,A(II),B(II) SSP00626
|
||
GO TO 800 SSP00627
|
||
4 D(I)=A(II)/B(II) SSP00628
|
||
EIGV(I)=D(I) SSP00629
|
||
10 II=II + N1 - I SSP00630
|
||
C SSP00631
|
||
```
|
||
|
||
<!-- source-page: 992 -->
|
||
|
||
```csv
|
||
DO 30 I=1,N
|
||
DO 20 J=1,N
|
||
20 X(I,J)=0.
|
||
30 X(I,I)=1.
|
||
IF (N.EQ.1) GO TO 900
|
||
INITIALIZE SWEEP COUNTER AND BEGIN ITERATION
|
||
NSWEEP=0
|
||
NR=N - 1
|
||
40 NSWEEP=NSWEEP + 1
|
||
IF (IFPR.EQ.1) WRITE (IOUT,2000) NSWEEP
|
||
CHECK IF PRESENT OFF-DIAGONAL ELEMENT IS LARGE ENOUGH TO REQUIRE ZEROING
|
||
EPS=(.01)**(NSWEEP*2)
|
||
DO 210 J=1,NR
|
||
JP1=J + 1
|
||
JM1=J - 1
|
||
LJK=JM1*N - JM1*J/2
|
||
JJ=LJK + J
|
||
DO 210 K=JP1,N
|
||
KP1=K + 1
|
||
KM1=K - 1
|
||
JK=LJK + K
|
||
KK=KM1*N - KM1*K/2 + K
|
||
EPTOLA=(A(JK)/A(JJ))*(A(JK)/A(KK))
|
||
EPTOLB=(B(JK)/B(JJ))*(B(JK)/B(KK))
|
||
IF (EPTOLA.LT.EPS .AND. EPTOLB.LT.EPS) GO TO 210
|
||
IF ZEROING IS REQUIRED, CALCULATE THE ROTATION MATRIX ELEMENTS CA AND CG
|
||
AKK=A(KK)*B(JK) - B(KK)*A(JK)
|
||
AJJ=A(JJ)*B(JK) - B(JJ)*A(JK)
|
||
AB=A(JJ)*B(KK) - A(KK)*B(JJ)
|
||
SCALE=A(KK)*B(KK)
|
||
ABCH=AB/SCALE
|
||
AKKCH=AKK/SCALE
|
||
AJJCH=AJJ/SCALE
|
||
CHECK=(ABCH*ABCH+4.0*AKKCH*AJJCH)/4.0
|
||
IF (CHECK) 50,60,60
|
||
50 WRITE (IOUT,2020) JJ,A(JJ),B(JJ)
|
||
GO TO 800
|
||
60 SQCH=SCALE*SQRT(CHECK)
|
||
D1=AB/2. + SQCH
|
||
D2=AB/2. - SQCH
|
||
DEN=D1
|
||
IF (ABS(D2).GT.ABS(D1)) DEN=D2
|
||
IF (DEN) 80,70,80
|
||
70 CA=0.
|
||
CG=-A(JK)/A(KK)
|
||
GO TO 90
|
||
80 CA=AKK/DEN
|
||
CG=-AJJ/DEN
|
||
PERFORM THE GENERALIZED ROTATION TO ZERO THE PRESENT OFF-DIAGONAL ELEMENT
|
||
90 IF (N-2) 100,190,100
|
||
10 IF (JM1-1) 130,110,110
|
||
10 DO 120 I=1,JM1
|
||
IM1=I - 1
|
||
IJ=IM1*N - IM1*I/2 + J
|
||
IK=IM1*N - IM1*I/2 + K
|
||
AJ=A(IJ)
|
||
BJ=B(IJ)
|
||
AK=A(IK)
|
||
BK=B(IK)
|
||
SSP00632
|
||
SSP00633
|
||
SSP00634
|
||
SSP00635
|
||
SSP00636
|
||
SSP00637
|
||
SSP00638
|
||
SSP00639
|
||
SSP00640
|
||
SSP00641
|
||
SSP00642
|
||
SSP00643
|
||
SSP00644
|
||
SSP00645
|
||
SSP00646
|
||
SSP00647
|
||
SSP00648
|
||
SSP00649
|
||
SSP00650
|
||
SSP00651
|
||
SSP00652
|
||
SSP00653
|
||
SSP00654
|
||
SSP00655
|
||
SSP00656
|
||
SSP00657
|
||
SSP00658
|
||
SSP00659
|
||
SSP00660
|
||
SSP00661
|
||
SSP00662
|
||
SSP00663
|
||
SSP00664
|
||
SSP00665
|
||
SSP00666
|
||
SSP00667
|
||
SSP00668
|
||
SSP00669
|
||
SSP00670
|
||
SSP00671
|
||
SSP00672
|
||
SSP00673
|
||
SSP00674
|
||
SSP00675
|
||
SSP00676
|
||
SSP00677
|
||
SSP00678
|
||
SSP00679
|
||
SSP00680
|
||
SSP00681
|
||
SSP00682
|
||
SSP00683
|
||
SSP00684
|
||
SSP00685
|
||
SSP00686
|
||
SSP00687
|
||
SSP00688
|
||
SSP00689
|
||
SSP00690
|
||
SSP00691
|
||
SSP00692
|
||
SSP00693
|
||
SSP00694
|
||
SSP00695
|
||
SSP00696
|
||
SSP00697
|
||
SSP00698
|
||
SSP00699
|
||
SSP00700
|
||
SSP00701
|
||
```
|
||
|
||
<!-- source-page: 993 -->
|
||
|
||
```csv
|
||
A(IJ)=AJ + CG*AK
|
||
B(IJ)=BJ + CG*BK
|
||
A(IK)=AK + CA*AJ
|
||
120 B(IK)=BK + CA*BJ
|
||
130 IF (KP1-N) 140,140,160
|
||
140 LJI=JM1*N - JM1*J/2
|
||
LKI=KM1*N - KM1*K/2
|
||
DO 150 I=KP1,N
|
||
JI=LJI + I
|
||
KI=LKI + I
|
||
AJ=A(JI)
|
||
BJ=B(JI)
|
||
AK=A(KI)
|
||
BK=B(KI)
|
||
A(JI)=AJ + CG*AK
|
||
B(JI)=BJ + CG*BK
|
||
A(KI)=AK + CA*AJ
|
||
150 B(KI)=BK + CA*BJ
|
||
160 IF (JP1-KM1) 170,170,190
|
||
170 LJI=JM1*N - JM1*J/2
|
||
DO 180 I=JP1,KM1
|
||
JI=LJI + I
|
||
IM1=I - 1
|
||
IK=IM1*N - IM1*I/2 + K
|
||
AJ=A(JI)
|
||
BJ=B(JI)
|
||
AK=A(IK)
|
||
BK=B(IK)
|
||
A(JI)=AJ + CG*AK
|
||
B(JI)=BJ + CG*BK
|
||
A(IK)=AK + CA*AJ
|
||
180 B(IK)=BK + CA*BJ
|
||
190 AK=A(KK)
|
||
BK=B(KK)
|
||
A(KK)=AK + 2.*CA*A(JK) + CA*CA*A(JJ)
|
||
B(KK)=BK + 2.*CA*B(JK) + CA*CA*B(JJ)
|
||
A(JJ)=A(JJ) + 2.*CG*A(JK) + CG*CG*AK
|
||
B(JJ)=B(JJ) + 2.*CG*B(JK) + CG*CG*BK
|
||
A(JK)=0.
|
||
B(JK)=0.
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
C
|
||
```
|
||
|
||
<!-- source-page: 994 -->
|
||
|
||
```csv
|
||
C
|
||
C CHECK ALL OFF-DIAGONAL ELEMENTS TO SEE IF ANOTHER SWEEP IS
|
||
C REQUIRED
|
||
C
|
||
EPS=RTOL**2
|
||
DO 250 J=1,NR
|
||
JM1=J - 1
|
||
JP1=J + 1
|
||
LJK=JM1*N - JM1*J/2
|
||
JJ=LJK + J
|
||
DO 250 K=JP1,N
|
||
KM1=K - 1
|
||
JK=LJK + K
|
||
KK=KM1*N - KM1*K/2 + K
|
||
EPSA=(A(JK)/A(JJ))*(A(JK)/A(KK))
|
||
EPSB=(B(JK)/B(JJ))*(B(JK)/B(KK))
|
||
IF (EPSA.LT.EPS .AND. EPSB.LT.EPS) GO TO 250
|
||
GO TO 280
|
||
250 CONTINUE
|
||
C
|
||
C SCALE EIGENVECTORS
|
||
C
|
||
255 II=1
|
||
DO 275 I=1,N
|
||
BB=SQRT(B(II))
|
||
DO 270 K=1,N
|
||
270 X(K,I)=X(K,I)/BB
|
||
275 II=II + N1 - I
|
||
GO TO 900
|
||
C
|
||
C UPDATE D MATRIX AND START NEW SWEEP, IF ALLOWED
|
||
C
|
||
280 DO 290 I=1,N
|
||
290 D(I)=EIGV(I)
|
||
IF (NSWEEP.LT.NSMAX) GO TO 40
|
||
GO TO 255
|
||
C
|
||
800 STOP
|
||
900 RETURN
|
||
C
|
||
2000 FORMAT (//,' SWEEP NUMBER IN *JACOB1* = ',I8)
|
||
2010 FORMAT ( ' ',6E20.12)
|
||
2020 FORMAT ( ' *** ERROR *** SOLUTION STOP',/,
|
||
1 ' MATRICES NOT POSITIVE DEFINITE',/,
|
||
2 ' II = ',I8,' A(II) = ',E20.12,' B(II) = ',E20.12)
|
||
2030 FORMAT (//,' CURRENT EIGENVALUES IN *JACOB1* ARE',/)
|
||
END
|
||
SSP00772
|
||
SSP00773
|
||
SSP00774
|
||
SSP00775
|
||
SSP00776
|
||
SSP00777
|
||
SSP00778
|
||
SSP00779
|
||
SSP00780
|
||
SSP00781
|
||
SSP00782
|
||
SSP00783
|
||
SSP00784
|
||
SSP00785
|
||
SSP00786
|
||
SSP00787
|
||
SSP00788
|
||
SSP00789
|
||
SSP00790
|
||
SSP00791
|
||
SSP00792
|
||
SSP00793
|
||
SSP00794
|
||
SSP00795
|
||
SSP00796
|
||
SSP00797
|
||
SSP00798
|
||
SSP00799
|
||
SSP00800
|
||
SSP00801
|
||
SSP00802
|
||
SSP00803
|
||
SSP00804
|
||
SSP00805
|
||
SSP00806
|
||
SSP00807
|
||
SSP00808
|
||
SSP00809
|
||
SSP00810
|
||
SSP00811
|
||
SSP00812
|
||
SSP00813
|
||
SSP00814
|
||
SSP00815
|
||
SSP00816
|
||
SSP00817
|
||
SSP00818
|
||
```
|
||
|
||
<!-- source-page: 995 -->
|
||
|
||
The subspace iteration program presented here is for the solution of the smallest eigenvalues and corresponding eigenvectors, where p is assumed to be small (say $p \leq 20$ ). Considering the solution of problems for a larger number of eigenpairs, the formula $q = \max\{2p, p + 8\}$ should be used, see K.J. Bathe [J].
|
||
|
||
Of course, in practice procedures for accelerating the basic subspace iteration solution given in subroutine SSPACE are very desirable, in particular, when a larger number of eigenpairs is to be calculated. Various acceleration procedures for the basic subspace iteration method have indeed been proposed, see for example K. J. Bathe and S. Ramaswamy [A], F.A. Dul and K. Arczewski [A], Q. C. Zhao, P. Chen, W. B. Peng, Y. C. Gong, and M. W. Yuan [A] and K. J. Bathe and J. Dong [A].
|
||
|
||
# 11.6.6 Exercises
|
||
|
||
11.18. Show explicitly that the iteration vectors $\mathbf{X}_{k + 1}$ in the subspace iteration are $\mathbf{K}$ - and $\mathbf{M}$ -orthogonal.
|
||
|
||
11.19. Use two iteration vectors in the subspace iteration method to solve for the two smallest eigenvalues and corresponding eigenvectors of the problem considered in Exercise 11.1.
|
||
|
||
11.20. Show that in the subspace iteration the use of (10.107) results after $(k-1)$ iterations into
|
||
|
||
$$
|
||
\left[ 1 - \frac {\left(\lambda_ {i} ^ {(k)}\right) ^ {2}}{\left(\mathbf {q} _ {i} ^ {(k)}\right) ^ {T} \mathbf {q} _ {i} ^ {(k)}} \right] ^ {1 / 2} \leq t o l
|
||
$$
|
||
|
||
where $\lambda_{i}^{(k)}$ is the calculated eigenvalue approximation and $\mathbf{q}_{i}^{(k)}$ is the corresponding eigenvector in $\mathbf{Q}_{k}$ .
|
||
|
||
11.21. The number of numerical operations used in program SSPACE can be decreased at the expense of using more memory. Then no additional iteration is performed after convergence. Reprogram SSPACE to achieve this decrease in numerical operations used.
|
||
|
||
11.22. Develop a program such as SSPACE using the programming language C (instead of Fortran), and compare the efficiencies of the two implementations.
|
||
|
||
<!-- source-page: 996 -->
|
||
|
||
# Implementation of the Finite Element Method
|
||
|
||
# 12.1 INTRODUCTION
|
||
|
||
In this book we have presented formulations, general theories, and numerical methods of finite element analysis. The objective in this final chapter is to discuss some important computational aspects pertaining to the implementation of finite element procedures. Although the implementation of displacement-based finite element analysis is discussed, it should be noted that most of the concepts presented can also be employed in finite element analysis using mixed formulations. Note, in particular, that the mixed interpolations of the u/p formulation for two- and three-dimensional continuum elements (see Sections 4.4.3, 5.3.5, and 6.4) and the mixed interpolations for beam, plate, and shell elements (see Sections 5.4 and 6.5) have only nodal displacements and rotations as final element degrees of freedom, and hence the process of element assemblage and solution of equations is as in the pure displacement-based formulation.
|
||
|
||
The main advantage that the finite element method has over other analysis techniques is its large generality. Normally, as was pointed out, it seems possible, by using many elements, to virtually approximate any continuum with complex boundary and loading conditions to such a degree that an accurate analysis can be carried out. In practice, however, obvious engineering limitations arise, a most important one being the cost of the analysis. This cost consists of the purchase and/or leasing of hardware and software, the analyst's effort and time required to prepare the analysis input data, the computer program execution time, and the analyst's time to interpret the results. Of course, as discussed in Section 1.2, a number of program runs may be required. Also, the limitations of the computer and the program employed may prevent the use of a sufficiently fine discretization to obtain accurate results. Hence, it is clearly desirable to use an efficient finite element program.
|
||
|
||
The effectiveness of a program depends essentially on the following factors. First, the use of efficient finite elements is important.
|
||
|
||
Second, efficient programming methods and sophisticated use of the available computer hardware and software are important. Although this aspect of program development
|
||
|
||
<!-- source-page: 997 -->
|
||
|
||
is computer-dependent, using standard FORTRAN 77 or C and high- and low-speed storage in a system-independent manner, very effective computer programs can be developed. If such a program is to be permanently installed on a specific computer, its efficiency may normally be increased with relatively little effort by making use of the specific hardware and software options available. In the following, we therefore discuss the design of finite element programs in which largely computer-independent procedures are used.
|
||
|
||
The third very important aspect of the development of a finite element program is the use of appropriate numerical techniques. As an example, if inappropriate techniques for the solution of the frequencies of a system in a dynamic analysis are employed, the cost may be many times greater than with effective techniques, and, even worse, a solution may not be possible at all if an unstable algorithm is employed. In order to implement the finite element method in practice, we need to use the digital computer. However, even with a relatively large-capacity computer available, the feasibility of a problem solution and the effectiveness of an analysis depend directly on the numerical procedures employed.
|
||
|
||
Assume that an actual structure has been idealized as an assemblage of finite elements. The stress analysis process can be understood to consist of essentially three phases:
|
||
|
||
1. Calculation of system matrices K, M, C, and R, whichever are applicable.
|
||
2. Solution of equilibrium equations.
|
||
3. Evaluation of element stresses.
|
||
|
||
In the analysis of a heat transfer, field, or fluid mechanics problem, the steps are identical, but the pertinent matrices and solution quantities need to be used.
|
||
|
||
The objective in this chapter is to describe a program implementation of the first and third phases and to present a small computer program that has all the important features of a general code. Although the total solution may be subdivided into the above three phases, it should be realized that the specific implementation of one phase can have a pronounced effect on the efficiency of another phase, and, indeed, in some programs the first two phases are carried out simultaneously (e.g., when using the frontal solution method; see Section 8.2.4).
|
||
|
||
As might be imagined, there is no unique optimum program organization for the evaluation of the system matrices; however, although program designs may appear to be quite different, in effect, some basic steps are followed. For this reason, it is most instructive to discuss in detail all the important features of one implementation that is based on classical methods. First we discuss the algorithms used, and then we present a small example program. This implementation is for a single processor machine but can be adapted for use of multiple processors and parallel computing.
|
||
|
||
# 12.2 COMPUTER PROGRAM ORGANIZATION FOR CALCULATION OF SYSTEM MATRICES
|
||
|
||
The final results of this phase are the required structure matrices for the solution of the system equilibrium equations. In a static analysis the computer program needs to calculate the structure stiffness matrix and the load vectors. In a dynamic analysis, the program must also establish the system mass and damping matrices. In the implementation to be described here, the calculation of the structure matrices is performed as follows.
|
||
|
||
<!-- source-page: 998 -->
|
||
|
||
1. The nodal point and element information are read and/or generated.
|
||
2. The element stiffness matrices, mass and damping matrices, and equivalent nodal loads are calculated.
|
||
3. The structure matrices K, M, C, and R, whichever are applicable, are assembled.
|
||
|
||
# 12.2.1 Nodal Point and Element Information Read-in
|
||
|
||
Consider first the data that correspond to the nodal points. Assume that the program is set up to allow a maximum of six degrees of freedom at each node, three translational and three rotational degrees of freedom, as shown in Fig. 12.1. Corresponding to each nodal point, it must then be identified which of these degrees of freedom shall actually be used in the analysis, i.e., which of the six possible nodal degrees of freedom correspond to degrees of freedom of the finite element assemblage. This is achieved by defining an identification array, the array ID, of dimension 6 times NUMNP, where NUMNP is equal to the number of nodal points in the system. Element $(i, j)$ in the ID array corresponds to the ith degree of freedom at the nodal point j. If ID(I, J) = 0, the corresponding degree of freedom is defined in the global system, and if ID(I, J) = 1, the degree of freedom is not defined. It should be noted that using the same procedure, an ID array for more (or less) than six degrees of freedom per nodal point could be established, and, indeed, the number of degrees of freedom per nodal point could be a variable. Consider the following simple example.
|
||
|
||
|
||
|
||
<details>
|
||
<summary>text_image</summary>
|
||
|
||
θz = 6
|
||
W = 3
|
||
Z
|
||
Y
|
||
V = 2 θy = 5
|
||
X
|
||
U = 1
|
||
θx = 4
|
||
</details>
|
||
|
||
Figure 12.1 Possible degrees of freedom at a nodal point
|
||
|
||
EXAMPLE 12.1: Establish the ID array for the plane stress element idealization of the cantilever in Fig. E12.1 in order to define the active and nonactive degrees of freedom.
|
||
|
||
The active degrees of freedom are defined by $ID(I, J) = 0$ , and the nonactive degrees of freedom are defined by $ID(I, J) = 1$ . Since the cantilever is in the X, Y plane and plane stress elements are used in the idealization, only X and Y translational degrees of freedom are active. By inspection, the ID array is given by
|
||
|
||
$$
|
||
\mathbf {I D} = \left[ \begin{array}{c c c c c c c c c} 1 & 1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 1 & 1 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \\ 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 & 1 \end{array} \right]
|
||
$$
|
||
|
||
<!-- source-page: 999 -->
|
||
|
||
|
||
|
||
<details>
|
||
<summary>text_image</summary>
|
||
|
||
Temperature at top face = 100°C
|
||
60 cm
|
||
60 cm
|
||
12
|
||
11
|
||
40 cm
|
||
40 cm
|
||
40 cm
|
||
Node
|
||
number
|
||
Temperature at
|
||
bottom face = 70°C
|
||
6
|
||
6
|
||
5
|
||
9
|
||
Element
|
||
number
|
||
E = 10⁶ N/cm²
|
||
v = 0.15
|
||
4
|
||
E = 2 × 10⁶ N/cm²
|
||
v = 0.20
|
||
10
|
||
2
|
||
5
|
||
3
|
||
8
|
||
9
|
||
1
|
||
3
|
||
1
|
||
2
|
||
E = 10⁶ N/cm²
|
||
v = 0.15
|
||
2
|
||
E = 2 × 10⁶ N/cm²
|
||
v = 0.20
|
||
8
|
||
1
|
||
4
|
||
7
|
||
7
|
||
Degree of
|
||
freedom
|
||
number
|
||
</details>
|
||
|
||
Figure E12.1 Finite element cantilever idealization
|
||
|
||
Once all active degrees of freedom have been defined by zeros in the ID array, the equation numbers corresponding to these degrees of freedom are assigned. The procedure is to simply scan column after column through the ID array and replace each zero by an equation number, which increases successively from 1 to the total number of equations. At the same time, the entries corresponding to the nonactive degrees of freedom are set to zero.
|
||
|
||
EXAMPLE 12.2: Modify the ID array obtained in Example 12.1 for the analysis of the cantilever plate in Fig. E12.1 to obtain the ID array that defines the equation numbers corresponding to the active degrees of freedom.
|
||
|
||
As explained above, we simply replace the zeros, column by column, in succession by equation numbers to obtain
|
||
|
||
$$
|
||
\mathbf {I D} = \left[ \begin{array}{c c c c c c c c c} 0 & 0 & 0 & 1 & 3 & 5 & 7 & 9 & 1 1 \\ 0 & 0 & 0 & 2 & 4 & 6 & 8 & 1 0 & 1 2 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \end{array} \right]
|
||
$$
|
||
|
||
Apart from the definition of all active degrees of freedom, we also need to read the X, Y, Z global coordinates and, if required, the temperature corresponding to each nodal point. For the cantilever beam in Fig. E12.1, the X, Y, Z coordinate arrays and nodal point temperature array T would be as follows:
|
||
|
||
$$
|
||
\begin{array}{l} \mathrm{X} = \left[ \begin{array}{l l l l l l l l l l} 0. 0 & 0. 0 & 0. 0 & 6 0. 0 & 6 0. 0 & 6 0. 0 & 1 2 0. 0 & 1 2 0. 0 & 1 2 0. 0 \end{array} \right] \\ \begin{array}{l} \mathrm{Y} = [ 0. 0 \quad 4 0. 0 \quad 8 0. 0 \quad 0. 0 \quad 4 0. 0 \quad 8 0. 0 \quad 0. 0 \quad 4 0. 0 \quad 8 0. 0 ] \\ \text {T} = [ 0. 0 \quad 4 0. 0 \quad 8 0. 0 \quad 0. 0 \quad 4 0. 0 \quad 8 0. 0 \quad 0. 0 \quad 4 0. 0 \quad 8 0. 0 ] \end{array} \tag {12.1} \\ Z = \left[ \begin{array}{l l l l l l l l l l} 0. 0 & 0. 0 & 0. 0 & 0. 0 & 0. 0 & 0. 0 & 0. 0 & 0. 0 & 0. 0 & 0. 0 \end{array} \right] \\ \mathbf {T} = \left[ \begin{array}{l l l l l l l l l} 7 0. 0 & 8 5. 0 & 1 0 0. 0 & 7 0. 0 & 8 5. 0 & 1 0 0. 0 & 7 0. 0 & 8 5. 0 & 1 0 0. 0 \end{array} \right] \\ \end{array}
|
||
$$
|
||
|
||
At this stage, with all the nodal point data known, the program may read and generate the element information. It is expedient to consider each element type in turn. For example,
|
||
|
||
<!-- source-page: 1000 -->
|
||
|
||
in the analysis of a container structure, all beam elements, all plane stress elements, and all shell elements are read and generated together. This is efficient because specific information must be provided for each element of a certain type, which, because of its repetitive nature, can be generated to some degree if all elements of the same type are specified together. Furthermore, the element routine for an element type that reads the element data and calculates the element matrices needs to be called only once.
|
||
|
||
The required data corresponding to an element depend on the specific element type. In general, the information required for each element is the element node numbers that correspond to the nodal point numbers of the complete element assemblage, the element material properties, and the surface and body forces applied to the element. Since the element material properties and the element loading are the same for many elements, it is efficient to define material property sets and load sets pertaining to an element type. These sets are specified at the beginning of each group of element data. Therefore, any one of the material property sets and element load sets can be assigned to an element at the same time the element node numbers are read.
|
||
|
||
EXAMPLE 12.3: Consider the analysis of the cantilever plate shown in Fig. E12.1 and the local element node numbering defined in Fig. 5.4. For each element give the node numbers that correspond to the nodal point numbers of the complete element assemblage. Also indicate the use of material property sets.
|
||
|
||
In this analysis we define two material property sets: material property set 1 for $E = 10^{6}$ N/cm $^{2}$ and $\nu = 0.15$ , and material property set 2 for $E = 2 \times 10^{6}$ N/cm $^{2}$ and $\nu = 0.20$ . We then have the following node numbers and material property sets for each element:
|
||
|
||
Element 1: node numbers: 5, 2, 1, 4; material property set: 1
|
||
|
||
Element 2: node numbers: 6, 3, 2, 5; material property set: 1
|
||
|
||
Element 3: node numbers: 8, 5, 4, 7; material property set: 2
|
||
|
||
Element 4: node numbers: 9, 6, 5, 8; material property set: 2
|
||
|
||
# 12.2.2 Calculation of Element Stiffness, Mass, and Equivalent Nodal Loads
|
||
|
||
The general procedure for calculating element matrices was discussed in Chapters 4 and 5, and a computer implementation was presented in Section 5.6. The program organization during this phase consists of calling the appropriate element subroutines for each element. During the element matrix calculations, the element coordinates, properties, and load sets, which have been read and stored in the preceding phase (Section 12.2.1), are needed. After calculation, either an element matrix may be stored on backup storage, because the assemblage into the structure matrices is carried out later, or the element matrix may be added immediately to the appropriate structure matrix.
|
||
|
||
# 12.2.3 Assemblage of Matrices
|
||
|
||
The assemblage process for obtaining the structure stiffness matrix $\mathbf{K}$ is symbolically written
|
||
|
||
$$
|
||
\mathbf {K} = \sum_ {i} \mathbf {K} ^ {(i)} \tag {12.2}
|
||
$$
|