Versuch einer Verkehrssimulation

[Timberjack]

ok das klingt alles ziemlich einleuchtend. Dies macht die Sache nun für mich nicht unbedingt einfacher, im Gegenteil. Denn ich frage mich nur, wie ich das ganze umsetzen sollte?

@MagBen: Wie gruppiere ich mir die Gitterpunkte? Ich hatte mir schon überlegt, dass ein Auto (besetzer Gitterpunkt) vor dem Vorrücken auf einen neuen Gitterpunkt erstmal kontrollieren sollte, ob dieser nicht besetzt ist. Um die Simulation erstmal zum Laufen zu bringen und die Fahrzeuge überschaubar zu halten, dachte ich zunächst an identische Autos. LKW, PKW mit Anhänger, Boote und Flugzeuge sowie Spurwechsel und Überholen hätte ich später versucht hinzuzufügen. Oder sollte ich das von Beginn an berücksichtigen?

[BlackJack]

Was das komplizierte angeht: Man muss immer im Auge behalten wie genau man die Wirklichkeit abbilden möchte. Wenn von ”oben” ein zellulärer Automat als mögliche Lösung vorgeschlagen wurde, dann wären das mit Abstand vor dem Auto variiert mit Geschwindigkeit und irgendwelchen komplizierteren Überholmaneuvern als der Wagen wechselt halt nicht nur einen Gitterpunkt in Längsrichtung, sondern auch noch einen quer, vielleicht nice to have, aber nicht wirklich nötig. Das hängt auch sicher ein wenig davon ab ob das eine Hausaufgabe mit 2 Wochen Zeit ist, wo man am Ende ein bisschen Code und ein paar Diagramme abgibt, und der Tutor da mal kurz drüber schaut, oder eher so etwas wie ein Seminar wo das ganze Semester genutzt werden kann, das Ergebnis vorgestellt und schriftlich ausgearbeitet werden muss.

[Timberjack]

mh verstehe. Grundsätzlich ist mir die methodische Umsetzung des Problems freigestellt. Den Zellulären Automaten hätte ich erstmal vorgezogen, da ich mir diesen selbst erstmal am Besten erklären kann. Leider habe ich kein ganzes Semester für diese Arbeit Zeit, eher ein paar Wochen.

[MagBen]

Hier ein Skizze, die Zeigt wie man mit Numpy Numerik machen kann.
Beachte das fehlen der Schleifen!

Code: Alles auswählen

#numerik wird mit Fortran, C++ oder Numpy gemacht
import numpy as N

#Strasse
#Einspurig, 1000 Elemente
#mit Index belegt: Auto, mit -1: frei
#aktueller Zustand
s1 = N.empty((1000,), dtype=N.int32)

#naechster Zeitschritt
s2 = N.empty((1000,), dtype=N.int32)

#Anfangszustand: 5 Autos (mehr moechte ich nicht tippen)
#Hier sind die Autos (location)
loc = N.array([0, 80, 95, 300, 400])

#Geschwindigkeiten (velocity)
v = N.array([10, 12, 5, 11, 7])

#Wir fuellen die Strasse
# alles leer
s1[:] = -1

#jetzt kommen die Autos
autos = N.arange(5, dtype=N.int32)
s1[loc] = autos

#naechster Zeitschritt
loc += v
s2[:] = -1
s2[loc] = autos

#swap s1, s2
s1,s2 = s2,s1

#Was hier fehlt:
#Ueberpruefung auf Sicherheitsabstand
#Konstanten 1 und 10. haengen davon ab,
#wie lang eine Strassenzelle ist und ein Zeitschritt
def sicherheitsabstand(v):
    return int(1+v**2/10.)

print "Weg frei fuer Auto 1:", not N.any( s1[ loc[1]+1 : loc[1]+sicherheitsabstand(v[1]) ]!=-1)
print "Weg frei fuer Auto 3:", not N.any( s1[ loc[3]+1 : loc[3]+sicherheitsabstand(v[3]) ]!=-1)

[Timberjack]

@MagBen: vielen Dank. Inzwischen habe ich auch ein wenig gebastelt und ein ähnliches herausgefunden. Dabei sind dann die Autos auf einer Strecke zufällig verteilt und fahren 10 Zeitschritte vorwärts

Code: Alles auswählen

import scipy as sc
import numpy as np
import pylab

# Dichte = Fahrzeuge pro Strecke (Streckenlaenge = 100m)
# Streckenlaenge
Streckenlaenge = 100

#Dichte = np.random.randn(1000)	   # wenn man von 10% Dichte auf der Gesamtstrecke ausgeht
Dichte = 0.1

# Totalanzahl an Autos
Fahrzeuganzahl = Dichte * Streckenlaenge

#Straße mit 100 Punkten
Track = np.zeros(Streckenlaenge)

# auf einer Strecke der Laenge sitzen an diesen Positionen Fahrzeuge
Fahrzeugposition = np.sort(np.ceil(np.random.rand(Fahrzeuganzahl)*Streckenlaenge))

print 'Anzahl der Fahrzeuge: ', Fahrzeuganzahl
print 'Fahrzeugpositionen: ', Fahrzeugposition

# Geschwindigkeitsprofil
# vorgegebene Durchschnittsgeschwindigkeit v = 10
mittlereGeschwindigkeit = 10
# jetzt der Vektor fuer alle Geschwindigkeiten (Gaußverteilt)
Anfangsgeschwindigkeit = np.ceil(np.random.randn(Fahrzeuganzahl) + mittlereGeschwindigkeit)

print 'Anfangsgeschwindigkeiten aller Fahrzeuge: ', Anfangsgeschwindigkeit

Orbit = []

#Ueberholen ist zugelassen, Fahrzeugposition und Geschwindigkeiten nach 10 Zeitschritten
Zeitschritte = 10
for i in range(Zeitschritte):
    Fahrzeugposition += Anfangsgeschwindigkeit
    Orbit.append(Fahrzeugposition*1.0)

print 'Anfangsgeschwindigkeit: ', Anfangsgeschwindigkeit
print 'Fahrzeugposition: ', Fahrzeugposition
print 'Fahrzeugposition nach 10 Durchläufen: ', Orbit

[BlackJack]

@MagBen: Nur das die Schleifen nicht wirklich fehlen, sondern irgendwo in den Numpy-Funktionen stecken. Das erscheint mir alles ein wenig umständlich wenn man die Positionen der Autos kennt in einer Schleife in |Sicherheitsabstand| Schritten Gitterpunkte zu überprüfen statt einfach den Abstand mit *einer* Rechenoperation auszurechnen. Das was Du gezeigt hast, kann man zum Beispiel auch so modellieren, dass man eine Spur durch eine nach Strechenposition sortierte Sequenz von Autos modelliert. Die kann man dann linear, paarweise durchgehen und ganz einfach die Entfernung zwischen beiden Fahrzeugen berechnen.