Mathesis Wiki

Wir hatten gestern das Problem, dass die Teilchen beim Stoßen ihre Geschwindigkeit nicht wesentlich betragsmäßig verändert haben und zudem hin und wieder an den Wänden festgeklebt sind. Diese Probleme haben wir behoben und uns heute vor allem mit dem Problem beschäftigt, dass die Teilchen zusammenkleben. Bei diesem Problem sind wir sehr viel weiter gekommen, in dem wir eine Überprüfung der jeweiligen letzten Stoßpartner eingeführt haben, die wiederholte Stöße von zwei Teilchen verhindert, falls nicht zwischendurch andere Einwirkungen stattgefunden haben, denn eigentlich sollte es ohne Stöße mit dritten oder der Wand nicht die Möglichkeit geben, mehrmals zu stoßen.
Ausschnitt aus der neuen Kollisions-Methode:

def handle_collision(self, b2):
        """überprüft Kollision mit anderen Teilchen und berechnet neue Geschwindigkeit"""
        abstand = np.linalg.norm(b2.position - self.position)
        if abstand <= self.radius + b2.radius and not (self.last_collision == b2 and b2.last_collision == self):
            # Zwischenspeicher für Geschwindigkeiten
            b1_vel_vec = self.vel_vec
            b2_vel_vec = b2.vel_vec

            # Berechnung elastischer Stoß
            self.vel_vec = (self.masse * b1_vel_vec + b2.masse * (2 * b2_vel_vec - b1_vel_vec)) / (
                        self.masse + b2.masse)
            b2.vel_vec = (b2.masse * b2_vel_vec + self.masse * (2 * b1_vel_vec - b2.vel_vec)) / (self.masse + b2.masse)

            self.last_collision = b2
            b2.last_collision = self

(Außerdem wird bei Stößen mit der Wand der Wert von self.last_collision zurückgesetzt)
Die Lösung lässt sich aber noch verbessern, da die Teilchen nun manchmal durch das brownsche Teilchen hindurchfliegen, insbesondere bei hohen Radiusunterschieden. Außerdem haben wir Sektoren eingeführt, also die Einteilung der Bälle in Gruppen mit ähnlichen Koordinaten, und so die Anzahl der überprüften Stöße pro Zeitschritt reduziert:

class Sector:
    '''Aufteilung von Teilchen in Listen(Sektoren), die je einem Abschnitt des Fensters zugeordnet sind'''
    def __init__(self):
        self.sec1 = []
        self.sec2 = []
        self.sec3 = []
        self.sec4 = []
    def sectorize(self,ball, height=HEIGHT, width=WIDTH):
        '''ordnet den Ball einem Sektor im Koordinatensystem zu'''
        if ball.position[0] >= width/2 and ball.position[1] >= height/2:
            self.sec1.append(ball)
            return(self.sec1)
        elif ball.position[0] < width/2 and ball.position[1] >= height/2:
            self.sec2.append(ball)
            return(self.sec2)
        elif ball.position[0] < width/2 and ball.position[1] < height/2:
            self.sec3.append(ball)
            return(self.sec3)
        else:
            self.sec4.append(ball)
            return(self.sec4)
    def flush(self):
        '''leert die Sektoren'''
        self.sec1 = []
        self.sec2 = []
        self.sec3 = []
        self.sec4 = []

neue Abfrage zur Kollision¹⁾ innerhalb von main:

 sector.flush()
        for ball in balls:
            own_sector = sector.sectorize(ball)
            ''' Bewegung und Kollision aller Teilchen'''
            ball.handle_border_collision()
            for i in range(len(own_sector)-1):
                ball.handle_collision(own_sector[i])
            ball.move()

Weiterhin kommt es allerdings vor, dass die Teilchen ineinander gespawnt werden und dann recht lang brauchen, um sich zu trennen. Wir haben momentan zwei Haupt-To-Dos:

• die Effizienz der Kollisionssimulation weiter zu verbessern, um mehr Teilchen (aktuell problemlos ~200) simulieren zu können
• die Position, Gerschwindigkeit und Beschleunigung, die momentan in jeweils zwei Variablen aufgeteilt sind, als Vektoren (numpy array) zu speichern und somit die Berechnungen zu vereinfachen.

Zusätzlich haben wir das Projekt auf github hochgeladen, um besser zusammenarbeiten zu können. Langfristig ist unser Ziel, die Bewegung in 3D zu simulieren, wofür wir noch nach einer geeigneten Bibliothek suchen müssen.

hoehenformel_stand07_03.rar