taralino

Projektaufgabe Wator-Welt

Mit dem Modell zur Simulation von Waldbränden hast du auch kennengelernt, was zelluläre Automaten eigentlich sind. Zur Vertiefung möchten wir dir als Projektaufgabe empfehlen, ein Räuber-Beute-Modell als zellulären Automaten zu modellieren und zu implementieren.

Die Aufgabe ist durchaus herausfordernd und als mittelfristige Projektaufgabe samt eigenständiger Recherche zu verstehen. Andererseits bietet dir die Aufgabe ein weiteres interessantes Modell und während der Bearbeitung wirst du sicher viel lernen.

Beschreibung

Räuber-Beute-Modelle dienen zur Beschreibung der zeitlichen Entwicklung der Populationsgrößen zweier konkurrierender Spezies. Zudem haben wir kennengelernt, dass zelluläre Automaten zur Modellierung und Simulation durchaus komplexer Situation verwendet werden können.

Die Aufgabe dieser Projektidee besteht darin, ein Räuber-Beute-Modell als zellulären Automaten zu modellieren sowie Simulationen und Analysen durchzuführen.

Genauer soll ein zellulärer Automat entworfen werden, auf dem zwei Spezies leben, nämlich Räuber und Beute. Die Beute-Tiere haben die Eigenschaft, dass sie sich in Bereichen ohne Räuber vermehren. Umgekehrt werden Räuber-Tiere verhungern und damit aussterben, wenn keine Beute in der Nähe ist. Treffen nun aber Beute und Räuber aufeinander, so kann es vorkommen, dass die Beute durch den Räuber gefressen wird und sich die Lebenserwartung des Räubers verlängert.

Als Simulation mit Fischen und Haien findet man ein derartiges Modell in der Literatur (oder auf Wikipedia) häufig als Wator-Modell oder Wator-Simulation beschrieben.

Literaturempfehlung

Neben Ergebnissen eigenständiger Recherchen können folgende Literaturquellen bei der Bearbeitung der Projektidee hilfreich sein:

D. Scholz. 2014. Pixelspiele. Modellierung und Simulieren mit zellulären Automaten. Springer Spektrum, Heidelberg, 1. Auflage.
A.K. Dewdney. 1984. Sharks and fish wage an ecological war on the toroidal planet Wa-Tor. Scientific America 251: 14-22.

Beispiel

Die folgende Anwendung zeigt eine Wator-Simulation bestehend aus Fischen (blau) und Haien (rot). Dies ist eine der vielen Lösungsmöglichkeiten dieser Projektidee.

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <script src="taralino.js"></script>
</head>
<body>
<script>

/*******************************
  Kennzahlen zur Simulation
*******************************/

// Spielfeld (Anzahl der Zeilen und Spalten):
var n = 60;

// Energie Beute:
var b = 4;

// Energie Raeuber:
var r = 8;

// Energie Fressen:
var c = 2;


/*******************************
  Globale Variablen
*******************************/

// Spielfeld erzeugen (zweidimensionales Datenfeld):
var S = [];
for (var i = 0; i < n; i++) S.push([]);
for (var i = 0; i < n; i++) for (var j = 0; j < n; j++) S[i].push(0);


/*******************************
  Funktion setup()
*******************************/

// Die Funktion wird jeweils beim Start einmalig aufgerufen.

function setup() {
  // Erzeugung der zufaelligen Startkonfiguration
  for (var i = 0; i < n; i++) for (var j = 0; j < n; j++) {
    S[i][j] = 0;
    if (random(0,1) < 0.20) S[i][j] = (random(0,1) < 0.50 ? b : b+r);
  };

  Grid.init(n, n, {style:"canvas", background:"lightgrey", zoom:6});
  Animation.init({fps:10});
};


/*******************************
  Funktion draw_grid()
*******************************/

// Die Funktion zeichnet das Spielfeld.

function draw_grid() {
  Grid.clear();
  for (var i = 0; i < n; i++) for (var j = 0; j < n; j++) {
    if ((S[i][j] >= 1) && (S[i][j] <= b)) Grid.pixel(i, j, "blue");
    if (S[i][j] > b) Grid.pixel(i, j, "red");
  };
  Grid.draw();
};


/*******************************
  Funktion calculate_step()
*******************************/

// Die Funktion fuehrt einen Simulationsschritt durch.

function random_permutation() {
  var p = [0,1,2,3];
  for (var k = 0; k < 3; k++) {
    var i = Math.floor(4*Math.random());
    var j = Math.floor(4*Math.random());
    var h = p[i];
    p[i] = p[j];
    p[j] = h;
  };
  return p;
};

function calculate_dev() {
  for (var i = 0; i < n; i++) for (var j = 0; j < n; j++) {
    if ((S[i][j] >= 1) && (S[i][j] < b)) S[i][j]++;
    if (S[i][j] == b+1) S[i][j] = 0;
    if (S[i][j] > b+1) S[i][j]--;
  };
};

function calculate_step() {
  var i = Math.floor(n*Math.random());
  var j = Math.floor(n*Math.random());
  var k = 0;
  var p = random_permutation();

  if ((S[i][j] >= 1) && (S[i][j] < b)) {
    while (k < 4) {
      if (p[k] == 0) if (S[(i+n+1)%n][j] == 0) { S[(i+n+1)%n][j] = S[i][j]; S[i][j] = 0; k = 4; }
      if (p[k] == 1) if (S[(i+n-1)%n][j] == 0) { S[(i+n-1)%n][j] = S[i][j]; S[i][j] = 0; k = 4; }
      if (p[k] == 2) if (S[i][(j+n+1)%n] == 0) { S[i][(j+n+1)%n] = S[i][j]; S[i][j] = 0; k = 4; }
      if (p[k] == 3) if (S[i][(j+n-1)%n] == 0) { S[i][(j+n-1)%n] = S[i][j]; S[i][j] = 0; k = 4; }
      k++;
    };
  };

  if (S[i][j] == b) {
    while (k < 4) {
      if (p[k] == 0) if (S[(i+n+1)%n][j] == 0) { S[(i+n+1)%n][j] = 1; S[i][j] = 1; k = 4; }
      if (p[k] == 1) if (S[(i+n-1)%n][j] == 0) { S[(i+n-1)%n][j] = 1; S[i][j] = 1; k = 4; }
      if (p[k] == 2) if (S[i][(j+n+1)%n] == 0) { S[i][(j+n+1)%n] = 1; S[i][j] = 1; k = 4; }
      if (p[k] == 3) if (S[i][(j+n-1)%n] == 0) { S[i][(j+n-1)%n] = 1; S[i][j] = 1; k = 4; }
      k++;
    };
  };

  if (S[i][j] > b) {
    while (k < 4) {
      if (p[k] == 0) if ((S[(i+n+1)%n][j] >= 1) && (S[(i+n+1)%n][j] <= b)) { var h = S[i][j]+c; if (h >= b+r) { h = b+Math.floor(0.5*(h-b)); S[(i+n+1)%n][j] = h; S[i][j] = h; } else { S[(i+n+1)%n][j] = h; S[i][j] = 0; } k = 9; }
      if (p[k] == 1) if ((S[(i+n-1)%n][j] >= 1) && (S[(i+n-1)%n][j] <= b)) { var h = S[i][j]+c; if (h >= b+r) { h = b+Math.floor(0.5*(h-b)); S[(i+n-1)%n][j] = h; S[i][j] = h; } else { S[(i+n-1)%n][j] = h; S[i][j] = 0; } k = 9; }
      if (p[k] == 2) if ((S[i][(j+n+1)%n] >= 1) && (S[i][(j+n+1)%n] <= b)) { var h = S[i][j]+c; if (h >= b+r) { h = b+Math.floor(0.5*(h-b)); S[i][(j+n+1)%n] = h; S[i][j] = h; } else { S[i][(j+n+1)%n] = h; S[i][j] = 0; } k = 9; }
      if (p[k] == 3) if ((S[i][(j+n-1)%n] >= 1) && (S[i][(j+n-1)%n] <= b)) { var h = S[i][j]+c; if (h >= b+r) { h = b+Math.floor(0.5*(h-b)); S[i][(j+n-1)%n] = h; S[i][j] = h; } else { S[i][(j+n-1)%n] = h; S[i][j] = 0; } k = 9; }
      k++;
    };
    if (k < 8) {
      k = 0;
      while (k < 4) {
        if (p[k] == 0) if (S[(i+n+1)%n][j] == 0) { S[(i+n+1)%n][j] = S[i][j]; S[i][j] = 0; k = 4; }
        if (p[k] == 1) if (S[(i+n-1)%n][j] == 0) { S[(i+n-1)%n][j] = S[i][j]; S[i][j] = 0; k = 4; }
        if (p[k] == 2) if (S[i][(j+n+1)%n] == 0) { S[i][(j+n+1)%n] = S[i][j]; S[i][j] = 0; k = 4; }
        if (p[k] == 3) if (S[i][(j+n-1)%n] == 0) { S[i][(j+n-1)%n] = S[i][j]; S[i][j] = 0; k = 4; }
        k++;
      };
    };
  };

};


/*******************************
  Funktion loop()
*******************************/

// Die Funktion wird automatisch immer wieder aufgerufen.

function loop() {
  for (var k = 0; k < n*n; k++) calculate_step();
  calculate_dev();
  draw_grid();
};


</script>
</body>
</html>

Vorschau Download Kopie speichern

Projektaufgabe

Modelliere ein Räuber-Beute-Modell als zellulären Automaten:

Fertige eine ausführliche Beschreibung deines Modells an (insbesondere Parameter und Regeln des zellulären Automaten).
Programmiere dein Modell und führe Simulationen durch.
Beobachte den zeitlichen Verlauf die beiden Populationen, d.h., die Anzahl der Beute- sowie die Anzahl der Räuber-Tiere jeweils in Abhängigkeit der Anzahl der Simulationsschritte.
Vergleiche den zeitlichen Verlauf der Populationen qualitativ mit den Lotka-Volterra-Gleichungen.