Reelle Zahlen

• Variablen, die grundsätzlich reelle Werte

annehmen können oder in Ausdrücken

erscheinen, die einen reelllen Wert liefern,

sollten vom Typ REAL sein.

Division ganzer Zahlen

• Betrachte die Auswertung der Anweisung a = b*c/d, wobei b eine reelle Variable mit dem Wert 100.0 ist, während c und d ganze Zahlen mit den Werten 9 und 10 sind.– b*c wird zuerst ausgewertet, wobei c zunächst in den

reellen Wert 9.0 umgewandelt wird.

– Danach wird der Wert von d in seinen reellen Gegenwert umgewandelt, bevor die Division ausgeführt wird.

Ellis et al. (1994), S. 48

Division ganzer Zahlen

• Was passiert, wenn der Ausdruck in der

folgenden, mathematisch gleichwertigen Form

geschrieben worden wäre: a = c/d*b ?

– In der ersten Operation sind beide Operanden ganze

Zahlen, so dass der Unterausdruck c/d als

ganzzahlige Operation ausgeführt wird.

– Das mathematische Ergebnis (0.9) wird

abgeschnitten und liefert ein Zwischenergebnis von

Null.

Ellis et al. (1994), S. 49

Literaturhinweis

• Ellis, T.M.R., Phillips, Ivor R., and Lahey,

Thomas M.: Fortran 90 Programming,

Addison-Wesley Publishing Company,

1994.

M. Schulz

Mathematical Operations

Deg_C = 5.0 * (Deg_F 32.0) / 9.0

The expression on the RHS is evaluated and

assigned to the REAL variable Deg_C

* is the multiplication operator,

is the subtraction operator,

/ is the division operator,

** is the exponentiation, and

= is the assignment operator.

M. Schulz

Important Built-In FunctionsABS(x) Absolute value

LOG(x) Natural logarithm

LOG10(x) Base-10 logarithm

EXP(x) Natural exponential

SQRT(x) Square root

SIN(x) Sine (x in radians!)

COS(x) Cosine

TAN(x) Tangent

ASIN(x) Arcsine

ACOS(x) Arccosine

ATAN(x) Arctangent

INT(x) Convert real to integer, truncation (7.8 7)

NINT(x) Convert real to integer, rounding (7.8 8)

REAL(i) Convert integer to real (1 1.0)

Unix-Tipp

• Wenn das aktuelle Verzeichnis “.” nicht im

Suchpfad enthalten ist, dann kann man ein

Programm a.exe mit dem Befehl

./a.exe starten.

Tipps zur Fehlersuche

• “PRINT”-Anweisungen einbauen, um den

Wert bestimmter Variablen zu überprüfen

• Spezielle Compileroptionen wählen, um

zum Beispiel Feldbereichsüberschrei-

tungen anzuzeigen

Option Bedeutung

g95 --help

g95 --target-help

g95 –fbounds-check Prüfe Feld- und

Zeichenkettengrenzen

G95-Optionen

Fortran-Links

• http://www.g95.org/

– http://www.g95.org/G95Manual.pdf

• http://de.wikibooks.org/wiki/Fortran

– http://de.wikibooks.org/wiki/

Fortran:_Fortran_95

– http://de.wikibooks.org/wiki/Fortran:_G95

Vergleichsoperatoren

Vergleichsoperator Bedeutung

< kleiner

<= kleiner oder gleich

== gleich

/= ungleich

> größer

>= größer oder gleich

Energiebilanzmodell(Aufgabe 4)

Projektübung Klimamodellierung (05-3034) – A. Paul

Punktmodell der Strahlungsbilanz

(Stocker 2004, Abschnitt 2.2)

414

dT Sh C T

dt

Gewöhnliche, nichtlineare Differentialgleichung erster Ordnung für die

unbekannte, zeitabhängige Variable T(t)

R 6371 km Erdradius

h 8.3 km Skalenhöhe

1.2 kg m-3 Luftdichte

C 1000 J kg-1 K-1 Spezifische Wärme

von Luft

T K Temperatur

0.3 Planetare Albedo

S 1367 W m-2 Solarkonstante

0.6 Emissions-

vermögen

5.67x10-8 W m-2 K-4 Stefan-Boltzmann-

Konstante

Gleichgewichtstemperatur des globalen Energiebilanzmodells: Die aus Messungen bestimmte mittlere Oberflächentemperatur beträgt 14°C (fett ausgezogen).

Eis-Albedo-Rückkopplung

• Die Eis-Albedo-Rückkopplung soll durch

folgende Abschätzung der Elbedo

parameterisiert werden:

0.42, falls 10 ,

0.62, falls 10 .

T C

T C

2 3

2 3

2 3

1 1( ) .

2 3!t t t

dT d T d TT t t T t t t t

dt dt dt

T(t) in eine Taylorreihe entwickeln:

2 3

2

2 3

( ) 1 1.

2 3!

Korrekturterm der Ordnung

t t t

T t t T tdT d T d Tt t

dt t dt dt

t

t = n t, n=0,1,2,…

Nach der ersten Ableitung auflösen: Euler-Schema

Diskretisierung

3 4

2 3

3 4

2

( ) 1 1.

2 3! 4!

Korrekturterm der Ordnung

t t t

T t t T t tdT d T d Tt t

dt t dt dt

t

Ersetzen von t durch -t und addieren:Schema der zentrierten Differenzen

, ,dy

f x y xdx

0 0 .y x y

4, , ( , ) 1 .4

Sy T x t f x y y

• Das Euler-Verfahren ist das einfachste, aber

auch ungenaueste Verfahren zur Lösung der

gewöhnlichen Differentialgleichung erster

Ordnung

mit der Anfangsbedingung

Im Fall des Energiebilanzmodells ist

• Das Euler-Verfahren wertet die

Ableitung nur an den Stellen x und x+x

aus.

• Dies entspricht der Linearisierung der

langwelligen Ausstrahlung.

• Genauere Verfahren vom Typ “Runge-

Kutta k-ter Ordnung” verwenden weitere

Stützstellen im Intervall [x, x+x]

Runge-Kutta-Verfahren k-ter Ordnung

• Durch die Auswertung von f(x,y) an

weiteren Stützstellen im Intervall [x, x+x]

und eine geschickte Linearkombination

kann der Fehler von O(x) auf O[(x)k]

reduziert werden

1

2 1

3 2

3 3

,

,2 2

,2 2

,2

n n

n n

n n

n n

K f x y

x xK f x y K

x xK f x y K

xK f x y x K

1 ,n n n ny y x F x y

1 2 3 4

1, 2 2

6n nF x y K K K K

Stocker (2004), S. 33

Die Vorschrift für das klassische Runge-Kutta-Verfahren 4. Ordung lautet:

Parameterisierte REAL-Variablen

• REAL-Variablen (reelle Zahlen) sind

„parameterisiert“.

• Der kind-Typparameter legt die

Anforderungen an die minimale

Genauigkeit und den Bereich des

Exponenten fest.

! Parameter declarations

! Symbolic name for a real kind type with at least ! 15 decimal digits of precision and an exponent range ! from 10**300 to 10**(-300) (“double precision”)INTEGER, PARAMETER :: dp=SELECTED_REAL_KIND(P=15,R=300)

! Symbolic name for a real kind type with at least ! 6 decimal digits of precision and an exponent range! from 10**30 to 10**(-30) (“single precision”)INTEGER, PARAMETER :: sp=SELECTED_REAL_KIND(P=6,R=30)

! Symbolic name for a default real kind typeINTEGER, PARAMETER :: q=dp

! Variable declarationsREAL(KIND=q) :: dpressREAL(KIND=q), DIMENSION(1:km) :: p

FUNCTION- und SUBROUTINE-Unterprogramme

• FUNCTION-Unterprogramme berechnen

einen einzigen Wert, der an der

Aufrufstelle eingesetzt wird.

• SUBROUTINE-Unterprogramme gestatten

die gleichzeizige Berechnung mehrerer

Werte.

SUBROUTINE rk4(y,dx,yp) IMPLICIT NONE

! Dummy arguments

REAL(KIND=q), INTENT(IN) :: y,dx

REAL(KIND=q), INTENT(OUT) :: yp

! Local variables

! dy1, dy2, dy3, dy4 = correspond to K1, K2, K3, K4 in

! fourth-order Runge-Kutta formula

REAL(KIND=q) :: dy1,dy2,dy3,dy4

dy1 = f(y)

dy2 = f(y + dx/2.0_q*dy1)

dy3 = f(y + dx/2.0_q*dy2)

dy4 = f(y + dx*dy3)

yp = (dy1 + 2.0_q*dy2 + 2.0_q*dy3 + dy4)/6.0

END SUBROUTINE rk4

FUNCTION- und SUBROUTINE-Unterprogramme

Block IF-Struktur

! Variable declarations! tol = criteria of convergence (K)REAL(KIND=q) :: tol[..]! Initializations tol = 1.0E-03_q[..]! Time loopDO itt=1,ittmax

[..]

! Test for convergence IF (ABS(tf – ti) < tol) THEN EXIT END IFEND DO