Simulieren Sie einen physikalischen Aufprall von Objekten aus endlichen, kleinen Elementen

Ich habe kürzlich so etwas gemacht, um ein System aus zwei Massen zu simulieren, die durch eine Feder verbunden sind. Diese Massen lagen horizontal auf einer reibungsfreien Ebene. Eine dieser Massen bekam einen ersten Impuls und danach wurde das System in Ruhe gelassen. Während sich das gesamte System (der zu messende Kontroid) mit konstanter Geschwindigkeit bewegt, oszillieren die beiden Massen, während sie sich vorwärts bewegen. Hier ist eine kurze ASCII-Zeichnung des Systems

 Initial Impulse     ______              ______ 
 ---->               | m1 |/\/\/\/\/\/\/\| m2 |
_____________________|____|______________|____|______________________

Nachdem ich die Differentialgleichungen aufgeschrieben hatte, schrieb ich ein kleines Python-Programm, das das Problem simulierte. Dieses Programm basiert auf der Methode der kleinen Schritte (auch Eueler-Methode genannt). Hier der entsprechende Wikipedia-Artikel:

http://en.wikipedia.org/wiki/Euler_method

Ich habe diesen Algorithmus für das oben beschriebene Problem implementiert und die Ergebnisse mit gnuplot gezeichnet:

gnuplot.info (Ich darf nur einen Hyperlink hinzufügen, also bitte www hinzufügen)

Es steht Ihnen jedoch frei, für diesen Zweck jedes beliebige Tool zu verwenden. Hier kommt der Sourcecode meines kleinen Programms:

#!/usr/bin/python
import os

steps = 100000
time = 100.

# Initial conditions
D = 0.9
m1 = 1.2
m2 = 0.4
v1 = 1.3
v2 = 0.
x1 = 0.
x2 = 1.
l = 1.

#Since I also tried to implement other algorithmus i specify which one to use
Euler = 1


#Euler 

if Euler == 1:
    timesteps = time / steps
    # Open the files for writing the results to
    f = open('results_x1', 'w')
    f2 = open('results_x2', 'w')
    f3 = open('results_com', 'w')

    # The real calculation   
    for i in range(0,steps):
        x1 = x1 + (D * (x2 - x1 -l) / m1)* (timesteps**2) + v1 * timesteps
        x2 = x2 - (D * (x2 - x1 -l) / m2)* (timesteps**2) + v2 * timesteps
        v1 = v1 + (D * (x2 - x1 -l) / m1)* (timesteps)
        v2 = v2 - (D * (x2 - x1 -l) / m2)* (timesteps)  
        f.write(str(i*timesteps) + " " + str(x1) + "\n")
        f2.write(str(i*timesteps) + " " + str(x2) + "\n")
        f3.write(str(i*timesteps) + " " + str((x1*m1 + x2*m2)/(m1+m2)) + "\n")


    f.close()
    f2.close()
    f3.close()

Natürlich gibt es bessere Algorithmus als den Euler-Algorithmus, aber dieser ist definitiv am einfachsten zu implementieren (ich habe es versäumt, fortgeschrittenere Algorithmen zu implementieren ;-)).

Dies sind also die Schritte, die Sie wahrscheinlich befolgen sollten:

• Schreiben Sie die Differentialgleichungen für Ihr Problem auf
• Verstehe die Euler-Methode
• Nehmen Sie meinen Code als Referenzpunkt und ändern Sie ihn für Ihr Problem

Ich weiß, dass dies ein ziemlich umfangreiches Thema ist und meine Antwort daher nur oberflächlich ist. Sagen Sie einfach, worüber Sie mehr wissen möchten, und ich werde versuchen, entsprechende Kommentare hinzuzufügen ;-)

Schauen Sie sich die Seite von Ron Fedkiw an ; Es ist ein guter Ausgangspunkt mit einem umfassenden Satz von Schlüsselwörtern.

es hängt davon ab, welche Art von Simulation Sie erstellen möchten:

Wenn Ihre Simulation den Zweck hat, ein simulatives Modell zu erstellen, das beispielsweise das experimentelle Rauschen vermeidet, möglicherweise mit einem komplexen Dynamikalgorithmus usw., denke ich, dass C oder C ++ die beste Wahl sind.

Wenn Sie andererseits eine schnelle Simulation mit grafischer Ausgabe und integrierten Analysewerkzeugen (vielleicht sogar für didaktische Zwecke) erstellen möchten, ist Python Ihre Wahl! In diesem Fall schlage ich vor, dass Sie sich die Enthought Python Distribution ansehen . Für den akademischen Gebrauch ist es Freeware und verfügt über eine integrierte Version von scipy.