Ameisen sind in Staaten ernormer Größe organisiert. Sie schaffen es in kurzer Zeit komplexe, effiziente Wegenetzen zu bilden, welche ihnen als Transportwege und Alarmsystem dienen. Dabei legen die Individuen Pheromonspuren aus, welche das Laufverhalten anderer Individuen beeinflussen. So reduziert sich das zufällige Pfadsystem einzelner Individuen in kurzer Zeit auf Hauptwege, welche über die Zeit optimiert werden. Weiterhin berücksichten wir Kollision einzelner Ameisen.

Wir wollen dieses komplexe Verhalten simulieren und reduzieren das Modell deshalb auf ein Minimum an Umwelteinflüssen (wie Temperatur, Wind, Terrain, …) . Die generierten Daten wollen wir anschließend auswerten und visualisieren und vieleicht nicht direkt ersichtliche Abhängigkeiten von Faktoren sichtbar machen.

1. Recherche biologischer Hintergründe
2. Dokumentationen vergleichbarer Simulationen nach Ansätzen durchsuchen
3. Klassen definieren
4. Zufällige Ameisenbewegung erzeugen
5. Geschwindigkeitsverringerung bei Annäherung verschiedener Ameisen
6. Kollisionsverhinderung
7. Pheromone erzeugen
8. Pheromonerzeugung mit Bewegung der Ameisen koppeln
9. Sensorik der Ameisen spezifizieren für die Erkennung von Pheromonkonzentrationen und damit Änderung der Bewegungsrichtung

Ameisen verlassen ihr Nest mehr oder weniger zufällig, orientieren sich jedoch an Temperatur und Licht (, worauf wir in unserer Simulation jedoch nicht eingehen). Ihren Weg markieren sie mit verschiedenen Pheromonen, abhängig von ihren Erlebnissen. Das Pheromon, auf das wir uns konzentrieren, wird bei der Futtersuche genutzt. Die Braunschwarze Rossameise, die wir als Vorbild nehmen, ernährt sich in Trophobiose (Symbiose von Ameisen und Blattläusen - Schutz durch Ameise gegen Nahrungsversorgung mit Honigtau durch Blattläuse) und Zoophagie (Ernährung von anderen Tieren, Carnivorismus), allerdings arbeiten wir mit stationären Nahrungsquellen, also konzentrieren wir uns auf die Trophobiose.

1: Die erste Ameise findet eine Futterquelle (F), benutzt den Weg (a), dann erreicht sie das Nest (N), und hinterlässt eine Pheromonspur.

2: Andere Ameisen folgen der ersten auf 4 möglichen Pfaden.

3: Die Ameisen folgen dem kürzesten Pfad.

Konsistente Pheromonspuren entstehen durch die Überlagerung von Pheromonspuren verschiedener Ameisen, die auf unterschiedlichen Routen das gleiche Ziel angesteuert haben. Ameisen nehmen Pheromone über die Fühler am Kopf war und bewegen sich zur höchsten Pheromonkonzentration, es sei denn, ein Artgenosse ist im Weg. In dem Fall versuchen sie auszuweichen. Jedoch kann der Drang, einer Kollision auszuweichen, durch eine entsprechend hohe Pheromonkonzentration ausgeschaltet werden, wodurch sogenannte „Ant mills“ entstehen: Kreise von Ameisen, die auf ihren eigenen Spuren weiterlaufen, da die Konzentration durch die schiere Menge an Ameisen so hoch ist, dass sie ihre eigenen Artgenossen tot trampeln, woher der alternative Name „Death Circle“ stammt.

Wenn eine Ameise auf eine konsistente Pheromonspur gerät, verfällt sie in eine Art „Zickzack“-Kurs, da sie im Versuch zur höchsten Pheromonkonzentration zu gelangen, immer wieder die Spur überqueren.

Unser Modell orientiert sich an der Braunschwarzen Rossameise. Deshalb nutzen wir folgende Werte:

Länge [lenght]: 10mm

Fühler Reichweite (Pheromonwahrnehmung) [head_radius]: 4mm

Winkel zwischen den Fühlern [head_angle]: 100°

Radius um den Körpermittelpunkt (Wahrnehmung anderer Objekte, u.a. Artgenossen) [center_radius]: 5mm

maximale Geschwindigkeit [max_speed]: 200 mm/s

minimale Geschwindigkeit [min_speed]: 5 mm/s

Geschwindigkeit [speed]: 100 mm/s

maximaler Drehwinkel [max_turn_angle]: 20°

• Abbildung in Python als UML

def simulate_steps(self, n = 1, redraw=True):
   for x in range(0,n):
      #update the world model
      self.world.update()
 
      if self.is_mode("live") and redraw:
         self.draw_data()
 
      if self.is_mode("live"):
         self.draw_data()

Das ist der Hauptteil unseres Programmes der über die python-Konsole bei Laufzeit nach belieben aufgerufen wird. def simulate_steps(self, n = 1, redraw=True): nimmt als Argumente die Anzahl der Simulationszyklen n und als optionalen Parameter eine boolean Variable redraw, die steuert ob der Bildschirm während den Zyklen geupdated werden soll oder erst nach Beendigung der Durchläufe.

self.world.update() updatet alle Objekte und die Pheromonmap in der Klasse World.

Da der Simulator zwischen reiner Berechnung (Record-Mode) und dynamischer Anzeige (Live-Mode) unterscheidet wird im zweiten Teil des Loops nur selektiv draw_data() aufgerufen.

• Duftstoffe verblassen (verlieren an Intensität über Zeit)
• Duftstoffe verteilen sich, sie diffundieren

Wir simulieren die Duftstoffe in der Welt mit einer großen Matrix mit ausreichend kleiner Rasterung. Über jedes Zeitintervall t berechnen wir die Diffusion mit Hilfe von scipy.signal.dissolve().

20.11
Recherche von Quellen
Koordination in der Gruppe
Erstellung eines gemeinsamen Dropbox Ordners anstelle einer Versionsverwaltung mit git o.ä.

27.11
Recherche
Programmierung des Gerüstes des Quellcodes

04.12
Wir haben uns heute das Grundgerüst des Codes angeschaut, bestehend aus den Modulen World und Simulator.
Wir haben Pheromone erstellt, die über Zeit verblassen
Einen allgemeinen Ablauf der Implemtierung festgelegt:

Schritt 1: Das Modell wird als Datenstruktur repräsentiert
Schritt 2: Ameisen laufen zufällig
Schritt 3: Ameisen weichen einander aus
Schritt 4: Ameisen folgen Pheromonen
Schritt 5: Die Variablen des Modells anpassen bis es der Natur ähnlich ist

11.12
Wir haben die Diffusion der Pheromone programmiert.

18.12
Heute ist kaum etwas passiert. Wir haben zufällige Pheromonzentren generiert und diffundieren lassen

15.12
Wir haben im Modell Abmessungen festgesetzt und angefangen Routinen für den Kolisionsalgorithmus zu implementieren. Dazu gehört andere Tiere innerhalb eines Radiuses r und einer position p zu finden oder auch innerhalb eines Teilbogens mit Richtungsvektor und winkel zu bestimmen.

def get_objects_in_range(self, pos, radius):
  '''returns a list of objects in a given range
     needs a position vector and a radius
  '''
 
  in_range = []
 
  for o in self.world_objects:
    if get_distance(o.position, pos) <= radius:
      in_range.append(o)
 
  return in_range
 
def get_objects_in_range_and_radius(self, pos, dir, radius, in_angle):
  '''returns a list of objects in a given range, direction and angle'''
 
  in_range = self.get_objects_in_range(pos, radius)
  in_angle = [];
 
  for o in in_range:
    o_direction = o.position - pos
    angle = get_angle(dir, o_direction)
 
    if 0 <= angle <= in_angle / 2:
      in_angle.append(o)
 
  return in_angle

22.01
Heute haben wir eine Funktion eingeführt die die Koordinaten aus dem Modell für die visuelle Abbildung umwandelt.
Dabei wir der Ursprung auf die Mitte des Fenstes verschoben und die Koordinaten werden in ganzahlige Werte umgewandelt.

def convert_coordinates(self, position_vector):
  screen_x, screen_y = self.screen.get_size()
 
  #transformation vector
  transform_v = np.array([screen_x / 2, screen_y / 2])
 
  #convert to integer array
  position_int = np.array(np.rint(position_vector + transform_v), dtype=np.int)
 
  return position_int

Die Ant-Klasse hat jetzt eine max_turn_rate die den maximalen Drehwinkel pro Frame limitiert.
Die Methode evade der Ant-Klasse funktioniert jetzt wie gewollt. Die Ameisen weichen sich aus.

t=0st=1,8s

Interaktionsradius von center_radius == 75mm

t=0.25s t=25.25s t=75.25s

22.01
Wir haben einen Fehler mit plötzlich viel zu großen und viel zu kleinen Zahlen während einer Durchschnittsberechnung behoben.
Finde ihn selber:

def get_weighted_collision_vector(self, object_list):
    v_matrix = np.empty((2), dtype=np.float64)
    for o in object_list:
        v = ((self.position - o.position) / np.linalg.norm(self.position - o.position))
        v_matrix = v_matrix + v
 
    print v_matrix.dtype
 
    average = np.mean(v_matrix, axis=0)
 
    return average

Ameisen folgen nun Pheromonen. (ausbaufähig)
Wir haben uns graphische Auswertungsmöglichkeiten zur Darstellung unserer Simulationsergebnisse überlegt.