Lineare FEM 1

1 Fortran Einführung
Im Rahmen der Linearen Finite Elemente Veranstaltungen werden wir das Programm
FEAPpv verwenden, welches in Fortran programmiert wurde. Hierzu ist eine generelles
Verständnis von Programmierung und im speziellen der Fortran Syntax erforderlich. Wir
geben im folgenden einen kurzen Überblick über Fortran.
Fortran Übersicht

program Beispiel Programmkopf für das Progamm Beispiel

implicit none zwingt zur Variablendeklaration
integer i,j deklariert integer i und j (Natürliche Zahlen)
real*8 a,b(5),c(2,2) deklariert die Zahl a, den Vektor b
und die Matrix c (Reelle Zahlen)
read(*,*) a erfordert eine Eingabe im Terminal und speichert sie
in Variable a ab
write(*,*) a zeigt Inhalt der Variable a auf dem Bildschirm an
open(1,file=’FILENAME.dat’) macht die Datei Filename.dat unter 1 bekannt
(Datei im selben Ordner wie Programm)
read(1,*) a,b liest die ersten beiden Zahlen aus der Datei 1 aus
und speichert sie in a,b
write(1,*) a schreibt Inhalt der Variable a in Datei 1
close(1) schließt Datei 1
! nach einem ! wird der Rest der Zeile ignoriert
(Kommentar)

Listing 1: do-Schleife
1 do i = 1 , 4
2 write ( ∗ , ∗ ) , i
3 d( i ) = d( i ) + 6
4 end do

Listing 2: if-Abfrage
1 i f ( a . gt . 5 ) . and . ( b . l t . 7 ) then
2 ! g t −> g r a t e r than (>) , l t −> l e s s than (<)
3 write ( ∗ , ∗ ) , ’ Eins ’
4 e l s e i f ( a . ge . 5 ) . or . ( b . l e . 7 ) then
5 ! ge −> g r a t e r e q u a l (>=) , l e −> l e s s e q u a l (<=)
6 write ( ∗ , ∗ ) , ’ Zwei ’
7 e l s e i f ( a . eq . 5 ) . or . ( b . ne . 7 ) then
8 ! eq −> e q u a l (=) , ne −> not e q u a l ( ˜ )
9 write ( ∗ , ∗ ) , ’ D r e i ’
10 e l s e then
11 write ( ∗ , ∗ ) , ’ e r r o r ’
12 end i f
 Fortran Einführung 2

Ein Programm mit dem GFortran Compiler kompilieren

Ist der Source Code eines Programms erstellt, soll dieser nun zu einem Programm kom-
piliert werden. Dies bedeutet, dass der Compiler die im Source Code enthaltenen Befehle
für den Prozessor übersetzt und eine Executable, also das Programm als solches erstellt.
Hierzu öffnet man ein Terminal/Konsole im Ordner indem der Source Code liegt, und
verwendet folgendes Kommando:
g f o r t r a n −o b e i s p i e l s o u r c e c o d e . f
| |
| Dateiname des Source Codes
Name d er e r s t e l l t e n E x e c u t a b l e

GFortran legt das erstellte Programm dann wieder in den Ordner indem auch der Source
Code liegt. Um ein Programm auszuführen ist folgendes Kommando in der Kommando-
zeile einzugeben:
./ beispiel

Der generelle Aufbau von Fortran Programmen ist einfach am Programm Hello World
zu erkennen, welches nichts anderes tut als den String Hello World auf dem Bildschirm
auszugeben.
Listing 3: Hello World
1 ! E r s t e s Programm
2 ! Regeln :
3 ! nach dem A u s r u f u n g s z e i c h e n werden Eingaben i g n o r i e r t −> Kommentare
4 ! Umlaute s i n d g e n e r e l l zu vermeiden
5 ! i n F o r t r a n haben d i e S p a l t e n e i n e b e s o n d e r e Bedeutung
6 ! 23456789.............................................................72
7 ! ||
8 ! | e r s t ab S p a l t e 7 werden B e f e h l e e r k a n n t
9 ! |
10 ! i n S p a l t e 6 kann mit einem &
11 ! i n d e r n a e c h s t e n Z e i l e w e i t e r g e s c h r i e b e n werden
12 ! A l l e Eingaben nach S p a l t e 72 werden i g n o r i e r t
13 ! e i n F o r t r a n Programm b e g i n n t mit dem ” h e a d e r ” −> Programmkopf
14 !
15 ! program i n i t i a l i s i e r t den Programmstart
16 ! | name d e s Programms
17 ! | |
18 program helloworld
19
20 write ( ∗ , ∗ ) , ’ h e l l o world ’
21
22 end program
23 ! |
24 ! b e e n d e t Programm
 Lineare FEM 3

Einen Überblick über für diese Veranstaltung relevante Datentypen verschafft das nach-
folgende Programm.
Listing 4: Datentypen in Fortran
1 ! Nach dem Programmkopf s o l l t e n a l l e verwendeten V a r i a b l e n
2 ! d e k l a r i e r t ( bekanntgemacht ) werden .
3
4 program datentypen
5
6 i m p l i c i t none ! e r z w i n g t d a s s a l l e verwendeten V a r i a b l e n
7 ! bekannt s e i n muessen
8
9 integer i , j ,k, l ! N a t u e r l i c h e Zahlen
10 r e a l ∗8 a,b, c ! R e e l l e Zahlen
11 r e a l ∗8 v(3) ! Vektor
12 r e a l ∗8 m( 3 , 3 ) ! Matrix
13 r e a l ∗8 f i e l d (3 ,3 ,3) ! m e h r d i m e n s i o n a l e s Feld
14
15 ! V a r i a b l e n s o l l t e n i n jedem F a l l i n i t i a l i s i e r t werden , um
16 ! s i c h e r zu s t e l l e n d a s s s i e den
17 ! gewuenschten Wert e n t h a l t e n .
18
19 i = 0 ; j = 0 ; k = 0 ; l = 0 ;
20
21 ! Bei r e a l typen muss d i e Endung . d0 g e s e t z t werden , damit
22 ! im Rahmen d e r C o m p u t e r g e n a u i g k e i t a l l e Nachkommastellen
23 ! mit N u l l b e l e g t werden .
24 a = 0 . d0 ; b = 0 . d0 ; c = 0 . d0 ;
25
26 ! Bei F e l d e r n ohne s p e z i f i s c h e n E i n t r a g , wird j e d e r
27 ! E i n t r a g a u f den e n t s p r e c h e n d e n Wert g e s e t z t .
28 v = 0 . d0 ;
29 m = 0 . d0 ;
30 ! Programm
31 ! V a r i a b l e n Werte z u w e i s e n
32 i = 1 ; j = 35 ; k = 9 ; l = 57 ;
33 a = 2 . d0 ; b = 0 . 5 d0 ; c = 3 . 5 6 d0 ;
34 v ( 1 ) = 1/2 ; v ( 2 ) = 1 . d0 / 3 . d0 ; v ( 3 ) = 9 . d0 / 8 . d0 ;
35
36 m( 1 , 1 ) = 2 ; m( 1 , 2 ) = 2 . 0 ; m( 1 , 3 ) = 2 . d0 ;
37 m( 2 , 1 ) = i ; m( 2 , 2 ) = j ; m( 2 , 3 ) = l ;
38 m( 3 , 1 ) = v ( 2 ) ; m( 3 , 2 ) = v ( 3 ) ; m( 3 , 3 ) = v ( 2 ) ∗ v ( 3 ) ;
39
40 write ( ∗ , ∗ ) , ’ H i e r l a s s e n w i r nun V a r i a b l e n a n z e i g e n ’
41 write ( ∗ , ∗ ) , ’ I n t e g e r ’ , i , j , k , l
42 write ( ∗ , ∗ ) , ’ r e a l ’ , a, b, c
43 write ( ∗ , ∗ ) , ’Nun e i n Vektor ’
44 write ( ∗ , ∗ ) , v
45 write ( ∗ , ∗ ) , ’Und s e i n e Laenge ’
46 write ( ∗ , ∗ ) , ’ l = ’ , sqrt ( v ( 1 ) ∗∗2 + v ( 2 ) ∗∗3 +v ( 3 ) ∗∗2 )
47 write ( ∗ , ∗ ) , ’ Eine Matrix ’
48 write ( ∗ , ∗ ) , m( 1 , 1 ) ,m( 1 , 2 ) , m( 1 , 3 )
49 write ( ∗ , ∗ ) , m( 2 , 1 ) ,m( 2 , 2 ) , m( 2 , 3 )
50 write ( ∗ , ∗ ) , m( 3 , 1 ) ,m( 3 , 2 ) , m( 3 , 3 )
51 ! Programm beenden
52 end program
 Fortran Einführung 4

Schließlich ist es noch wichtig zu wissen, wie Daten aus einer externen Datei eingelesen
bzw. in eine solche Exportiert werden können.
1 ! Programmkopf
2 program i m p o r t e x p o r t
3 i m p l i c i t none
4 ! Variablen d e k l a r i e r e n
5 integer i , j , k , l
6 r e a l ∗8 a , d e t
7 r e a l ∗8 v ( 6 )
8 r e a l ∗8 m( 2 , 2 )
9 ! Variablen i n i t i a l i s i e r e n
10 i = 0 ; j = 0 ; k = 0 ; l = 0 ;
11 a = 0 . d0 ; d e t = 0 . d0 ; v = 0 . d0 ; m = 0 . d0 ;
12 ! Externe D a t e i e n
13 open ( 1 , f i l e= ’ import . dat ’ , status= ’ o l d ’ )
14 open ( 2 , f i l e= ’ matrix . dat ’ , status= ’ o l d ’ )
15 open ( 3 , f i l e= ’ e x p o r t . dat ’ , status= ’ r e p l a c e ’ )
16 ! | | |
17 ! | | old , new , r e p l a c e , unknown
18 ! | Name d e r D a t e i
19 ! Channel u n t e r dem im Programm a u f d i e D a t e i zuge−
20 ! g r i f f e n werden kann .
21 ! Daten E i n l e s e n
22 ! Eingabeaufforderung
23 write ( ∗ , ∗ ) ’ Geben S i e e i n e Zahl e i n ’
24 read ( ∗ , ∗ ) a
25 ! E i n l e s e n aus D a t e i e n
26 read ( 1 , ∗ ) v ( 1 ) , v ( 2 ) , v ( 3 ) , v ( 4 ) , v ( 5 ) , v ( 6 )
27 read ( 2 , ∗ ) m( 1 , 1 ) ,m( 1 , 2 ) ,m( 2 , 1 ) ,m( 2 , 2 )
28 ! Programm
29 ! Determinante d e r Matrix b e r e c h n e n
30 d e t = m( 1 , 1 ) ∗ m( 2 , 2 ) − m( 1 , 2 ) ∗ m( 2 , 1 )
31 ! Ausgaben
32 write ( ∗ , ∗ ) , ’ e i n g e l e s e n e Daten ’
33 write ( ∗ , ∗ ) , ’ I h r e Terminal Eingabe : ’ , a
34 write ( ∗ , 1 0 0 ) , ’ Aus D a t e i i m p o r t i e r t : ’ , v
35 write ( ∗ , ∗ ) , ’ Aus D a t e i i m p o r t i e r t e Matrix : ’
36 write ( ∗ , ∗ ) , m( 1 , 1 ) ,m( 1 , 2 )
37 write ( ∗ , ∗ ) , m( 2 , 1 ) ,m( 2 , 2 )
38 write ( ∗ , ∗ ) , ’ Die Determinante d i e s e r Matrix l a u t e t : ’
39 write ( ∗ , 1 0 0 ) , ’ d e t= ’ , d e t
40 ! Pr ot o ko ll in Datei e x p o r t i e r e n
41 write ( 3 , ∗ ) , ’ e i n g e l e s e n e Daten ’
42 write ( 3 , ∗ ) , ’ I h r e Terminal Eingabe : ’ , a
43 write ( 3 , 1 0 0 ) , ’ Aus D a t e i i m p o r t i e r t : ’ , v
44 write ( 3 , ∗ ) , ’ Aus D a t e i i m p o r t i e r t e Matrix : ’
45 write ( 3 , ∗ ) , m( 1 , 1 ) ,m( 1 , 2 )
46 write ( 3 , ∗ ) , m( 2 , 1 ) ,m( 2 , 2 )
47 write ( 3 , ∗ ) , ’ Die Determinante d i e s e r Matrix l a u t e t : ’
48 write ( 3 , 1 0 0 ) , ’ d e t= ’ , d e t
49 ! Externe D a t e i e n s c h l e i s s e n
50 close (1) ; close (2) ; close (3)
51 ! Formatvorgaben
52 100 format (A, 1 0 0 f 1 0 . 4 )
53 ! Programm beenden
54 end program
 Lineare FEM 5

Das letzte Programmbeispiel zeigt verschiedene Möglichkeiten von Berechnungen und

Funktionsnutzungen die von Fortran unterstützt werden, wie beispielsweise die Winkel-
funktionen.
1 ! Programmkopf
2 program f u n c t i o n s
3 i m p l i c i t none
4 ! Variablen d e k l a r i e r e n
5 integer i , j , k , l
6 r e a l ∗8 a , b , c
7 r e a l ∗8 v ( 8 )
8 r e a l ∗8 m( 3 )
9 ! Variablen i n i t i a l i s i e r e n
10 i = 0 ; j = 0 ; k = 0 ; l = 0 ;
11 a = 0 . d0 ; b = 0 . d0 ; c = 0 . d0 ;
12 v = 0 . d0 ; m = 0 . d0 ;
13 ! Programm
14 ! E i n l e s e n e i n e r Zahl
15 write ( ∗ , ∗ ) , ’ geben S i e e i n e Zahl e i n ’
16 read ( ∗ , ∗ ) , a
17
18 ! Berechnungen
19
20 v ( 1 ) = exp ( a ) ! e hoch a
21 v ( 2 ) = log ( a ) ! Logarithmus a
22 ! W i n k e l f u n k t i o n e n b e z i e h e n s i c h a u f Bogenmass
23 v ( 3 ) = sin ( a ) ! S i n u s von a
24 v ( 4 ) = cos ( a ) ! C o s i n u s von a
25 v ( 5 ) = tan ( a ) ! Tangens von a
26 v ( 6 ) = sqrt ( a ) ! Wurzel von a
27 v ( 7 ) = a ∗∗2 ! a zum Quadrat
28 v ( 8 ) = a ∗∗5 ! a hoch 5
29 b = max( v ( 1 ) , v ( 2 ) , v ( 3 ) , v ( 4 ) , v ( 5 ) , v ( 6 ) , v ( 7 ) , v ( 8 ) )
30 c = min( v ( 1 ) , v ( 2 ) , v ( 3 ) , v ( 4 ) , v ( 5 ) , v ( 6 ) , v ( 7 ) , v ( 8 ) )
31 m( 1 ) = int ( a )
32 m( 2 ) = nint ( a )
33 m( 3 ) = abs ( a )
34
35 ! Ausgabe
36 write ( ∗ , ∗ ) , ’ Die e i n g e g e b e n e Zahl war : ’ , a
37 write ( ∗ , ∗ ) , ’ g e r u n d e t e r g i b t S i e : ’ ,m( 2 )
38 write ( ∗ , ∗ ) , ’ ohne i h r e Nachkommastellen e r h a e l l t man : ’ ,m( 1 )
39 write ( ∗ , ∗ ) , ’ I h r Betrag i s t : ’ ,m( 3 )
40 write ( ∗ , ∗ ) , ’ e ˆ a= ’ , v ( 1 )
41 write ( ∗ , ∗ ) , ’ l n ( a )= ’ , v ( 2 )
42 write ( ∗ , ∗ ) , ’ S i n u s ( a )= ’ , v ( 3 )
43 write ( ∗ , ∗ ) , ’ C o s i n u s ( a )= ’ , v ( 4 )
44 write ( ∗ , ∗ ) , ’ Tangens ( a )= ’ , v ( 5 )
45 write ( ∗ , ∗ ) , ’ Wurzel ( a )= ’ , v ( 6 )
46 write ( ∗ , ∗ ) , ’ aˆ2= ’ , v ( 7 )
47 write ( ∗ , ∗ ) , ’ aˆ5= ’ , v ( 8 )
48 write ( ∗ , ∗ ) , ’ g r o e s s t e Zahl im Vektor v : ’ , b
49 write ( ∗ , ∗ ) , ’ k l e i n s t e Zahl im Vektor v : ’ , b
50
51 ! Programm beenden
52 end program
 Fortran Einführung 6

2 Schleifen
Schleifen bilden eines der grundlegendsten Konzepte der Programmierung. Der Anwender
kann sich so direkt zu nutze machen, dass ein Computer in der Lage ist Operationen sehr
schnell nacheinander auszuführen. Im Rahmen der Linearen FEM nutzen wir Schleifen
für verschiedene Operationen. Eine wichtige Anwendung liegt in der Vektor-Matirzen
Rechnung. Das generelle Konzept einer Schliefe, im folgenden loop, liegt darin, dass das
Argument innerhalb der loop eine bestimmte Anzahl an Wiederholungen erfährt. Häufig
nutzt man auch die Möglichkeit, dass ein Integer innerhalb einer loop automatisch mit
jedem neuen Durchgang um 1 erhöht wird. Eine Syntax zum erstellen einer loop in Fortran
ist Abbildung 1 zu entnehmen. Das folgende Beispiel zeigt die Anwendung einer loop und
beschreibt den Ablauf. Hier ist zu sehen, wie die loop innerhalb ihrer 6 Durchgänge alle
um jeweils 1 erhöhten i Werte aufsummiert.
1 ! Programmkopf
2 program l o o p
3 i m p l i c i t none
4 ! Variablen d e k l a r i e r e n
5 integer i
6 r e a l ∗8 e
7 ! Variablen i n i t i a l i s i e r e n
8 i = 0 ; e = 0 . d0
9 ! Programm
10 ! Ausfuehren e i n e r Loop ( l o o p = S c h l e i f e )
11
12 do i = 1 , 6
13 ! | | | |
14 ! | | | l e t z t e r Wert den i annehmen s o l l
15 ! | | e r s t e r Wert den i s t a r t e n s o l l
16 ! | i n t e g e r , d e r i n d e r l o o p v e r a e n d e r t wird
17 ! Beginn e i n e s l o o p s
18
19 write ( ∗ , ∗ ) i ! g i b t den a k t u e l l e n Wert von i im t e r m i n a l aus
20
21 e = e + i ! a d i e r t i auf e ( immer den a k t u e l l l e n Wert von i )
22 ! f u e r i von 1 b i s 6 wird a l s o u e b e r d i e l o o p :
23 ! Beginn : e = 0.0 i = 1.0
24 ! Schritt 1: e = 0.0 + 1.0 −> e = 1 . 0
25 ! Schritt 2: e = 1.0 + 2.0 −> e = 3 . 0
26 ! Schritt 3: e = 3.0 + 3.0 −> e = 6 . 0
27 ! Schritt 4: e = 6.0 + 4.0 −> e = 1 0 . 0
28 ! Schritt 5: e = 10.0 + 5.0 −> e = 1 5 . 0
29 ! Schritt 6: e = 15.0 + 6.0 −> e = 2 1 . 0
30
31 end do ! commando b e e n d e t l o o p
32
33 write ( ∗ , ∗ ) e ! Ausgabe von e nach d e r S c h l e i f e
34
35 ! Programm beenden
36 end program
 Lineare FEM 7

Ein weiteres Beispiel ist durch das Programm factorial gegeben. Auch hier kann die
Arbeitsweise einer loop gut nachvollzogen werden.
1 ! Programmkopf
2 program f a c t o r i a l
3 i m p l i c i t none
4 ! Variablen d e k l a r i e r e n
5 integer i , j
6 r e a l ∗8 e , a , p
7 ! Variablen i n i t i a l i s i e r e n
8 i = 0 ; j = 0 ; p = 0 . d0 ; a = 0 . d0
9 ! Programm
10 ! E i n l e s e n e i n e r Zahl
11 write ( ∗ , ∗ ) ’ Geben S i e e i n e Zahl e i n ’
12 read ( ∗ , ∗ ) a
13
14 ! Fakultaet berechnen ( a ! )
15 p = 1 . d0
16 j = a
17 do i = 1 , j
18 p = p ∗ i
19 end do
20
21 ! Ausgabe
22 write ( ∗ , ∗ ) ’ Die F a k u l t a e t d e r e i n e g e g e b e n e n Zahl l a u t e t : ’
23 write ( ∗ , 1 0 ) a , ’ ! = ’ , p
24 ! Format
25 10 format ( f 1 0 . 2 , A , f 1 0 . 2 )
26 ! Programm beenden
27 end program
 Fortran Einführung 8

3 Fortran Anwendung
Im Folgenden wird am Beispiel des eindimensionalen Zugstab Problems gezeigt, wie prak-
tischer Nutzen aus einem Fortran Programm gezogen werden kann.

3.1 1D Zugstab Problem

Aus der Technischen Mechanik ist das Problem eines einseitig gehaltenen Zugstabes be-
kannt. Wir betrachten diesen Fall im Folgenden im Eindimensionalen, sowie mit über die
Stablänge konstanten Materialparametern.

E, A = const.
F

Abbildung 1: 1D Zugstab Problem

Ebenfalls bekannt sind die Lösungen für dieses Problem aus der Technischen Mechanik.
F ·l
Längung : ∆l =
E·A
N
Spannung : σ =
A
∆l
Dehnung : ε =
l

Das Programm zum unten dargestellten Quellcode, ließt die entsprechenden Problemva-
riablen aus einer Eingabe-Datei aus, und besitzt so eine gewisse Flexibilität. Das heißt,
dass es nicht für geänderte Problemvariablen neu kompiliert werden muss.
Prinzipiell werden hier bekannte analytische Lösungen für die eingelesenen Variablen be-
rechnet und ansprechend ausgegeben.
 Lineare FEM 9

Listing 5: Zugstab Problem

1 ! Programmkopf
2 program t e n s i o n t r u s s
3 i m p l i c i t none
4 ! Variablen d e k l a r i e r e n
5 r e a l ∗8 l e n g h t , area , e , f
6 r e a l ∗8 d e l t a l , lnew , s t r e s s , s t r a i n
7 ! Variablen i n i t i a l i s i e r e n
8 l e n g h t = 0 . d0 ; a r e a = 0 . d0 ; e = 0 . d0 ; f = 0 . d0 ;
9 d e l t a l = 0 . d0 ; lnew = 0 . d0 ; s t r e s s = 0 . d0 ; s t r a i n = 0 . d0 ;
10 ! Programm
11 ! E i n l e s e n e i n e r Zahl
12 open ( 1 , f i l e= ’ t r u s s i n p u t . dat ’ , status= ’ o l d ’ )
13 read ( 1 , ∗ ) , l e n g h t , area , e , f
14
15 ! Laengung b e r e c h n e n ( d e l t a l = ( f ∗ l ) / ( e ∗ a ) )
16 d e l t a l = ( f ∗ lenght ) /( e∗ area )
17 lnew = lenght + d e l t a l
18 ! Spannung b e r e c h n e n (F=N ; sigma = N / A)
19 s t r e s s = f / area
20 ! Dehnung b e r e c h n e n ( Eps = d e l t a l / l )
21 strain = d e l t a l / lenght
22
23 ! Ausgabe
24 write ( ∗ , ∗ ) , ’ ’
25 write ( ∗ , ∗ ) , ’ Tension Truss Problem : ’
26 write ( ∗ , ∗ ) , ’ ’
27 write ( ∗ , ∗ ) , ’ E ,A ’
28 write ( ∗ , ∗ ) , ’X−−−−−−−−−−−−−−−−−−−−−−−−−−O −−> ’
29 write ( ∗ , ∗ ) , ’ |............ l .............| F’
30 write ( ∗ , ∗ ) , ’ ’
31 write ( ∗ , ∗ ) , ’ Der Stab l a e n g t s i c h um: ’
32 write ( ∗ , 1 0 ) , deltal
33 write ( ∗ , 2 0 ) , ’ Er v e r l a e n g e r t s i c h a l s o von ’ , l e n g h t
34 write ( ∗ , 2 0 ) , ’ a u f ’ , lnew
35 write ( ∗ , ∗ ) , ’ Es h e r s c h t e i n e k o n s t a n t e Spannung von : ’
36 write ( ∗ , 1 0 ) , stress
37 write ( ∗ , ∗ ) , ’ Es h e r s c h t e i n e k o n s t a n t e Dehnung von : ’
38 write ( ∗ , 1 0 ) , strain
39
40
41 10 format ( 1 0 f 1 0 . 4 )
42 20 format (A, 2 0 f 1 0 . 4 )
43 30 format ( 3 0 f 1 0 . 4 ,A)
44 ! Programm beenden
45 end program
 Fortran Einführung 10

3.2 Matrix-Vektor Operationen

Das folgende Programm nutzt Schleifen, um Matrix-Vektor Operationen zu realisieren.
Dies sind wichtige Grundlagen für die computergestützte Anwendung der Methode der
finiten Elemente im Rahmen dieses Kurses.
Das unten aufgeführte Programm ließt aus zwei Input-Dateien Werte aus und füllt mit
ihnen ein Vektorfeld und ein Matrixfeld. Im Anschluss wird der Anwender durch Eingabe
eines Integer Wertes die Größe angeben, die für die Berechnungen verwendet werden. Beim
Erstellen eines solchen Codes ist es immer ratsam mit kleineren Feldern zu beginnen, um
die Ergebnisse von Hand überprüfen zu können.
Die erste Berechnung erstellt ein Skalarprodukt des eingelesenen Vektors mit sich selbst.
   
v1 v1
v·v =s  v2  ·  v2  = v1 · v1 + v2 · v2 + v3 · v3 = s
v3 v3

Die gezeigte Operation addiert in jedem Durchgang das Produkt der Einträge, die jeweils
in der gleichen Zeile stehen, auf einen real*8 Wert auf. Da dieser zuvor mit 0.d0 initiali-
siert wurde, ist das Ergebnis im Rahmen der Computergenauigkeit exakt. Anschließend
wird eine Matrix-Vektor Multiplikation gezeigt. Hierbei werden zwei Schleifen ineinander
verstrickt. Der Algorithmus kann wieder leicht aus der mathematischen Vorschrift erkannt
werden.
    
A11 A12 v1 A11 · v1 + A12 · v2
Av = n =
A21 A22 v2 A21 · v1 + A22 · v2

Bei dieser Operation ist das Ergebnis kein Skalar, sondern ein Vektor. Wir erhalten bei
der geizeigten 2x2 Operation für die Einträge des Lösungsvektors:

n(1) = A(1,1) * v(1) + A(1,2) * v(2)

n(2) = A(2,1) * v(1) + A(2,2) * v(2)

Wir benutzen nun Schleifen, um den jeweils ansteigenden Parameter automatisch anstei-
gen zu lassen.

do i = 1,2
n(i) = A(i,1) * v(1) + A(i,2) * v(2)
end do

Schließlich verwenden wir eine verschachtelte Schleife, um die automatisch Das Produkt
innerhalb einer Zeile zu erhalten. Nun ist es notwendig, die einzelnen Produkte auf den
Eintrag aufzusummieren.

do i = 1,2
do j = 1,2
n(i) = n(i) + A(i,j) * v(j)
end do
end do
 Lineare FEM 11

Dieser Algorithmus kann nun auf eine beliebige Größe von Feldern (Matrizen, Vektoren)
angewendet werden.
1 ! Programmkopf
2 program v e c t o r
3 i m p l i c i t none
4 ! Variablen d e k l a r i e r e n
5 integer i , j , k , s i z e
6 r e a l ∗8 s c a l a r
7 r e a l ∗8 m( 8 0 , 8 0 ) , v ( 8 0 ) , vv ( 8 0 )
8 integer row , c o l ! b e n o e t i g t f u e r Matrix Ausgabe
9 ! Variablen i n i t i a l i s i e r e n
10 i = 0 ; j = 0 ; k = 0 ; size = 0
11 v = 0 . d0 ; m = 0 . d0 ; s c a l a r = 0 . d0 ; vv = 0 . d0
12 ! Externe D a t e i e n
13 open ( 1 , f i l e= ’ matrix2 . dat ’ , status= ’ o l d ’ )
14 open ( 2 , f i l e= ’ v e c t o r . dat ’ , status= ’ o l d ’ )
15 ! Programm
16 read ( 1 , ∗ ) m
17 read ( 2 , ∗ ) v
18
19 write ( ∗ , ∗ ) ’ Dimension d e r O p e r a t i o n angeben (max = 8 0 ) : ’
20 read ( ∗ , ∗ ) size
21
22 ! Vector Vektor M u l t i p l i k a t i o n ( S k a l a r m u l t i p l i k a t i o n )
23 do i = 1 , s i z e
24 s c a l a r = s c a l a r + v ( i ) ∗v ( i )
25 end do
26 ! Matrix Vektor M u l t i p l i k a t i o n ( Matrix ∗ Vektor = Vektor )
27 do i = 1 , s i z e
28 do j = 1 , s i z e
29 vv ( i ) = vv ( i ) + m( i , j ) ∗ v ( j )
30 end do
31 end do
32
33 ! Ausgabe
34 write ( ∗ , ∗ ) , ’ Verwendete Matrix ’
35 do row = 1 , s i z e
36 write ( ∗ , 1 0 ) (m( row , c o l ) , c o l =1, s i z e )
37 end do
38 write ( ∗ , ∗ ) , ’ Verwendeter Vector ’
39 do row = 1 , s i z e
40 write ( ∗ , 1 0 ) ( v ( row ) )
41 end do
42 write ( ∗ , ∗ ) , ’ S k a l a r p r u d u k t d e s V e k t o r s mit s i c h s e l b s t e r g i b t : ’
43 write ( ∗ , ∗ ) , ’ v ∗ v = ’ , s c a l a r
44 write ( ∗ , ∗ ) , ’ Das Matrix Vektor Produkt e r g i e b t : ’
45 do row = 1 , s i z e
46 write ( ∗ , 2 0 ) ( vv ( row ) )
47 end do
48
49 ! Format
50 10 format ( 1 0 f 7 . 2 )
51 20 format ( 2 0 f 1 2 . 2 )
52 ! Programm beenden
53 end program