taralino

Variation der Parameter

In diesem Abschnitt wollen wir schließlich den Einfluss der Parameter und insbesondere hinsichtlich dem Anteil der Baum-Zellen analysieren. Dazu führen wir die gleiche Simulation wie zuvor durch, wobei das Spielfeld nicht mehr explizit dargestellt wird.

Zudem nutzen wir einen kleinen hilfreichen (aber nicht unbedingt notwendigen) Trick, um die statistischen Schwankungen der Analyse zu reduzieren: Die Anteile der jeweiligen Zell-Typen werden gefiltert (d.h. im gewissen Sinne gemittelt), um mögliche periodische Schwingungen zu verringern.

Selbstorganisierte Kritikalität

Das Ziel der folgenden Analyse ist es, die sogenannte selbstorganisierte Kritikalität zu beobachten: Selbst wenn die Parameter und durchaus stark variiert werden, stellt sich (nach dem Einschwingvorgang) ein stets ähnlicher Anteil an Bäumen auf dem Spielfeld ein. Die nachfolgende Anwendung dient dazu, sich hiervon selbst zu überzeugen.

Anwendung

Zur Beobachtung der selbstorganisierte Kritikalität.

<!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 = 320;


/*******************************
  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);

/*
Fuer das Spielfeld gelte:
Asche : S[i][j] = 0
Baum  : S[i][j] = 1
Feuer : S[i][j] = 2
*/

// Datenfeld zur Statistik:
var H = [0,0,0];

var A = [0.02,0.10,0.20];
var B = [0.0001,0.00001,0.000001];
var Ai = 0;
var Bi = 0;

var a = A[0];
var b = B[0];

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

function init() {
  for (var i = 0; i < n; i++) for (var j = 0; j < n; j++) {
    S[i][j] = 0;
    if (random(0,1) < 0.50) S[i][j] = 1;
  };
  H = [0,0,0];
  for (var i = 0; i < n; i++) for (var j = 0; j < n; j++) H[S[i][j]]++;
  Canvas.clear();
  Canvas.text(100, 20, "a = " + a.toFixed(2));
  Canvas.text(220, 20, "b = " + b.toFixed(6));
  draw_grid();
  draw_statistics();
};


function setup() {
  Grid.init(n, n, {style:"canvas", zoom:1});
  Chart.init(320, 80, {digits:0, color:["olive","lime","red"]});
  Canvas.init([0,320], [0,40], {width:320, background:"lightgrey"});
  Button.add("a", "Wert a");
  Button.add("b", "Wert b");
  Button.add("start", "Start");
  Button.add("stop", "Pause");
  Animation.init({fps:40, autoplay:"off"});
  init();
};



/*******************************
  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] == 0) Grid.pixel(i, j, "olive");
    if (S[i][j] == 1) Grid.pixel(i, j, "lime");
    if (S[i][j] == 2) Grid.pixel(i, j, "red");
  };
  Grid.draw();
};


/*******************************
  Funktion draw_statistics()
*******************************/

// Die Funktion berechnet und zeichnet die Statistik.

function draw_statistics() {
  var G = [0,0,0];
  for (var i = 0; i < n; i++) for (var j = 0; j < n; j++) G[S[i][j]]++;
  for (var k = 0; k < 3; k++) H[k] = H[k] + 0.05*(G[k]-H[k]);
  Chart.bar(H, {style:"single", label:"rate"});
  Chart.draw();
};


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

// Die Funktion fuehrt einen Simulationsschritt durch.

function calculate_step() {
  var T = [];
  for (var i = 0; i < n; i++) T.push([]);
  for (var i = 0; i < n; i++) for (var j = 0; j < n; j++) T[i].push(0);

  for (var i = 0; i < n; i++) for (var j = 0; j < n; j++) {
    // Asche-Zelle:
    if (S[i][j] == 0) {
      T[i][j] = 0;
      if (random(0,1) < a) T[i][j] = 1;
    };
    // Baum-Zelle:
    if (S[i][j] == 1) {
      T[i][j] = 1;
      if (S[(i+1)%n][j] == 2) T[i][j] = 2;
      if (S[(i+n-1)%n][j] == 2) T[i][j] = 2;
      if (S[i][(j+1)%n] == 2) T[i][j] = 2;
      if (S[i][(j+n-1)%n] == 2) T[i][j] = 2;
      if (random(0,1) < b) T[i][j] = 2;
    };
    // Feuer-Zelle:
    if (S[i][j] == 2) {
      T[i][j] = 0;
    };
  };

  return T;
};


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

// Die Funktion wird automatisch immer wieder aufgerufen.

function loop() {
  S = calculate_step();
  draw_grid();
  draw_statistics();
};


/*******************************
  Funktion on_click()
*******************************/

// Definition der Button-Interaktionen.

function on_click(id) {
  if (id == "start") Animation.start();
  if (id == "stop") Animation.stop();
  if (id == "a") {
    Animation.stop();
    Ai = (Ai + 1) % A.length;
    a = A[Ai];
    init();
  };
  if (id == "b") {
    Animation.stop();
    Bi = (Bi + 1) % B.length;
    b = B[Bi];
    init();
  };
};


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

Vorschau Download Kopie speichern

Aufgabe

Nutze die Anwendung zuvor, um die selbstorganisierte Kritikalität zu beobachten.

Führe jeweils eine Simulation für unterschiedliche Werte von und durch und protokolliere den (mittleren) Anteil der Baum-Zellen in Prozent (nach dem Einschwingvorgang).