Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Sie befinden sich hier: start » ss15 » schwarmtechnologie
Zuletzt angesehen: • schwarmtechnologie

Seitenleiste

ss15:schwarmtechnologie

Inhaltsverzeichnis

Einleitung

Die Gruppe Schwarmtechnologie des Mathesislabors beschäftigt sich mit der Entwicklung eines Multiagentencodes, der in der Projektwerkstattverbund „Ingenium“ und „Pronetz“http://www.tu-berlin.de/?101577 mittels Aerostaten umgesetzt werden soll.

Etappenziele

  1. Analyse der vorherigen Schwarmtechnologie im Mathesis-Labor
  2. Analyse weiterer Schwarmtechnologien
  3. Aufstellung eines einhaltbaren Lastenheft
  4. Umsetzung sowie Adaption des vorherigen Quellcodes
  5. Simulation
  6. Bau kleiner Schwarmeinheiten mit Lego
  7. im besten Fall Umsetzung bei Pronetz

Quellen\Literatur\Vorlagen

benötigte Materialien

  • Lego-Mindstorm-Set
  • ggf. Arduino

Teilnehmer

Felix Fürnhammer, Mathis Hertel, Tim Zander, Gereon Siévi

Protokoll Projektwoche 1.

  • Python lernen
  • tubcloud einrichten zum Informationsaustausch
  • Ziele besprechen (für nächste Woche und allgemein)
  • Gruppenorganisation
  • Ziele zur nächsten Woche: Python zu Ende lernen und Schwärme recherchieren.

Protokoll Projektwoche 2.

  • Experimente mit Vpython
  • Absprache der Modells:
    • Welt soll 2-dimensional sein und die Agenten haben einen Radius(ggf. mit Abschwächung).
    • Die Welt wird in Quadrate aufgeteilt die einen Bedarf haben, der unter dem Radius abnimmt und sonst stetig steigt.
    • Es wird einen zufälligen Bedarfsgenerator geben, der für ein zufälliges Quadrat den Bedarf erhöht.
  • Schwärme der vorherigen Mathesisgeneration werden analysiert
  • Boids wird „aufgebohrt werden“http://vpython.org/contents/contributed/boids.py
  • Boids 2Dhttp://code.activestate.com/recipes/502216-boids-demonstration/

Protokoll Projektwoche 3.

Protokoll Projektwoche 4.

  • Implementierung der Raster-Klasse
  • Erste Versuche die voll abgedeckten Kluster ein zu färben

Raster Code: 

class Raster:
    def __init__(self,n,widmin=0,widmax=700,heimin=0,heimax=700):
        self.abdeckung=np.zeros((n,n))
        self.bedarf=np.zeros((n,n))
        self.n=n
 
    def xy_to_ij(self,x,y):
        """ erwartet zwei Pixel Koordinaten und gibt sie als Koordinaten des Rasters zurück"""
        i=int(np.floor(x/siderec))
        j=int(np.floor(y/siderec))
        return (i,j)
 
    def ij_to_xy(self,siderec,i,j):
        """ wie xy_to_ij nur halt anders herum"""
        for m in range((i*siderec),((i+1)*siderec)):
            for n in range((j*siderec),((j+1)*siderec)):
                menge_xy=[(m,n)]
        return menge_xy
 
    def corner(self,siderec,rectanglenumber):
        """ gibt eine Liste aller Eckkoordinaten des Rasters in Pixel Koordinaten zurück"""
        l_c=[]
        for s in range(0,rectanglenumber):
            for t in range(0,rectanglenumber):
                l_c.append([s*siderec,t*siderec])
        return l_c
 
    def dist2(self,x,y,boid):
        """ gibt den Abstand von einem Punkt (x,y) zu einem Boid an"""
        #erwartet x,y-Koordinaten in Pixeln
        #und eine Variable des Typs Boid
        dista=(x-boid.position.x)**2+(y-boid.position.y)**2
        return dista
 
    def corner_in_halo(self,l_c,rad):
            """ gibt eine Liste der Rasterfelder zurück, die von den Boids Abgedeckt werden"""
            abgedeckt=[]
            for corner in l_c:
                if corner in abgedeckt:
                    break
                for boid in boids:
                    if dist2(boid,corner[0],corner[1])<=rad**2:
                        abgedeckt.append(corner)
            return abgedeckt
 
    def rasta_abgedeckt(self,abgedeckt):
        """ prüft ob auch alle Ecken des Rasterfeldes vom Boid abgedeckt werden"""
        abgedeckt_rasta=[]
        for i in range(0,rectanglenumber):
                if (i,i) and (i+1,i) and (i,i+1) and (i+1,i+1) in abgedeckt:
                    abgedeckt_rasta.append((i,i))
        return abgedeckt_rasta

Protokoll Projektwoche 5

  • Arbeit an der Einfärbung des abgedeckten Klusters in der Sprechstunde
  • Debuggen der Version und weitere Arbeit an dem Kluster,
    • Fehler: Bei einer Stringliste wurden Floats abgeglichen, die offensichtlich nicht gefunden wurden.

Korrigierter code der Funktion rasta_abgedeckt: 

    def rasta_abgedeckt(self,abgedeckt):
        abgedeckt_rasta=[]
        for i in range(0,rectanglenumber*siderec,siderec):
            for j in range(0,rectanglenumber*siderec, siderec):
                if ([i,j] in abgedeckt)  \
                and ([i+siderec,j] in abgedeckt)\
                and ([i,j+siderec] in abgedeckt)\
                and ([i+siderec,j+siderec] in abgedeckt):
                    abgedeckt_rasta.append((i,j))
        return abgedeckt_rasta
  • Außerdem liegen die Boids nun wieder farblich über dem in blau abgedeckten Kluster

Aussehen der Boids in Woche 5:

Projektwoche 6

  • Ziel der Woche: Die Boidsradien sollen sich überschneiden und so eine „Kette“ bilden.
    • evtl. übers clumping geregelt.
  • Weitere Analyse und Experimente mit Code
  • Sehnsucht nach Stefan
  • Kommentierung
  • Clumping erheblich verändert
  • Superclumping bzw. Superavoidance einrichten?!?
  • Prioritätenverteilung auf dem „Boden“

Projektwoche 7

Projektwoche 8

  • Tim und Gereon haben in der letzten Woche das Projekt im Rahmen der MintGrün Projektpräsentation vor gestellt

Projekttage

  • Tag 1: Erzeugung von rot eingefärbten Zielfeldern, die sich auflösen wenn sie abgedeckt werden. Danach wird ein neues Ziel erzeugt.
  • Tag 2: Arbeit darann eien „Zugpferd“ zu definieren hinter welchem sich die vorhandenen Boids anordnen
  • Tag 3: Wir experimentieren mit einem zweiten Ziel für unsere Boids und schauen, wie sich diese dazu verhalten, optimal wäre, wenn sie eine Kette zwischen diesen bilden. Wir Modularisieren den Code und beenden die schriftliche Ausarbeitung und Kommentierung.
    • Die Modularisierung hat nicht geklappt da der Code scheinbar mit Querverweisen arbeitet die sich nicht auf verschiedene Module verteilen lassen,
  • Leider werden wir es nicht mehr schaffen den Code in die Realität umzusetzen.

Lernergebnis

1. Wir haben Grundlagen von Python gelernt und deren Interaktion dazu gehören:

  • Schleifen
  • Listen
  • Objekte

2. Projektmanagment in der Informatik:

  • Zeit- und Aufgabeneinteilung in der Informatik
  • Bedeutung des klaren Programmierens(sprechende Namen und Kommentierung)
  • Dokumentation der Arbeit
ss15/schwarmtechnologie.txt · Zuletzt geändert: 2016/05/10 14:46 (Externe Bearbeitung)

Seiten-Werkzeuge

Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki