12.6    DGL-System mit zwei Unbekannten

Wenn zwei Differenzialgleichungen miteinander gekoppelt werden, dann entsteht ein DGL-System mit zwei Unbekannten. Das ist z. B. der Fall, wenn eine Population y₂ (Räuber) sich ausschließlich von einer anderen Population y₁ (Beute) ernährt. Die Beziehung zwischen der Beute und dem Räuber kann durch folgendes DGL-System beschrieben werden:

Darin bedeutet:

• c₁: Wachstumskoeffizient der Beute

• d₁, d₂: Wahrscheinlichkeit, mit der Beute und Räuber zusammentreffen

• c₂: Sterberate der Räuber

Der zweite Term d₁y₁y₂ in der 1. DGL besagt, dass die Anzahl der Beutetiere abnimmt, je größer die Wahrscheinlichkeit ist, dass sich Räuber und Beute treffen. Wenn die Räuber aussterben würden oder es zu keiner erfolgreichen Jagd kommen würde, dann würden sich die Beutetiere exponentiell vermehren.

Der zweite Term d₂y₁y₂ in der 2. DGL besagt, dass sich mit jeder erfolgreichen Jagd die Bedingungen für eine Fortpflanzung der Räuber verbessern. Wenn die Räuber keine Beute mehr finden, würden sie aussterben.

Diese idealisierte Beschreibung durch zwei miteinander gekoppelte Differenzialgleichungen gilt generell für jede Räuber-Beute-Beziehung. Aufgestellt wurden die Gleichungen 1925 von Alfred J. Lotka und, unabhängig von ihm, 1926 von Vito Volterra. Sie werden heute als lotka-volterrasches Räuber-Beute-Modell bezeichnet [Arens: 1034].

Listing 12.9 simuliert für 500 Beutetiere und 50 Raubtiere die zeitliche Entwicklung einer Räuber-Beute-Beziehung:

01  #09_plot_raueber_beute.py
02  import matplotlib.pyplot as plt
03  y1=500   #Beute
04  y2=50    #Räuber
05  c1=0.25  #Reproduktionsrate der Beute
06  c2=0.5   #Sterberate der Räuber
07  d1=0.001 #Beutewahrscheinlichkeit
08  d2=0.001
09  #DGL
10  def dgl(t,y1,y2):
11      dy1_dt= c1*y1 - d1*y1*y2  #Beute
12      dy2_dt=-c2*y2 + d2*y1*y2  #Räuber
13      return dy1_dt,dy2_dt
14  #Lösung der DGL
15  n=500
16  t1=0
17  t2=50
18  dt=(t2-t1)/n
19  lt,ly1,ly2=[t1],[y1],[y2]
20  for i in range(n):
21      t=t1+i*dt
22      dy1,dy2=dgl(t,y1,y2)
23      y1 = y1 + dy1*dt #Beute
24      y2 = y2 + dy2*dt #Räuber
25      lt.append(t),
26      ly1.append(y1)
27      ly2.append(y2)
28  #Grafikbereich
29  fig,ax = plt.subplots(2,1)
30  #Räuber-Beute-Beziehung
31  ax[0].plot(lt,ly1,'b--',label='Beute')
32  ax[0].plot(lt,ly2,'r',label='Räuber')
33  ax[0].legend(loc='best')
34  ax[0].set_xlabel('Zeit')
35  ax[0].grid(True)
36  #Phasendiagramm
37  ax[1].plot(ly1,ly2,'g')
38  ax[1].set(xlabel='Beute',ylabel='Räuber')
39  ax[1].grid(True)
40  fig.tight_layout()
41  plt.show()

Listing 12.9     Simulation einer Räuber-Beute-Beziehung

Ausgabe

Abbildung 12.10     Entwicklung einer Räuber-Beute-Beziehung

Analyse

In den Zeilen 10 bis 13 steht die Definition des Differenzialgleichungssystems. Die Python-Funktion dgl() gibt die 1. Ableitungen für die DGL der Beute und die DGL der Räuber zurück. Das DGL-System muss in expliziter Form vorliegen, sonst kann es mit dem Euler-Verfahren nicht gelöst werden. In der englischen Fachliteratur wird solch ein System auch häufig als rhs() bezeichnet, was als Abkürzung für right hand side steht.

In Zeile 22 wird die Python-Funktion dgl() mit den Anfangswerten aufgerufen und dem Tupel dy1, dy2 zugewiesen. In den Zeilen 23 bis 24 wird das DGL-System mit Summenalgorithmus gelöst. Die diskreten Lösungen werden in die Listen ly1 und ly2 gespeichert und in den Zeilen 31 und 32 als Funktionsplot ausgegeben.

In Zeile 37 zeichnet die Matplotlib-Methode plot(ly1,ly2,...) das Phasendiagramm.