Różnice

Różnice między wybraną wersją a wersją aktualną.

--- narzedzia:apple_sim_py [2025/05/07 11:56] – administrator
+++ narzedzia:apple_sim_py [2025/05/16 18:48] (aktualna) – administrator
@@ Linia 1: / Linia 1: @@
-= Symulacja Masy Sprężystej =
+Skrypt do pobrania:
+{{ :narzedzia:apple_sim.py |}}
-Ten artykuł opisuje działanie skryptu w Pythonie wykonującego symulację ruchu kulki pod wpływem siły grawitacji, wiatru oraz oddziaływania sprężysto‐tarciowego. Skrypt wykorzystuje biblioteki NumPy, Matplotlib oraz Tkinter do wizualizacji i interakcji.
+{{ :narzedzia:apple_sim_rr36t2xzdr.gif|}}
-== Spis treści ==
+====== PY: Symulacja Masy Sprężystej ======
-# Opis ogólny
-# Stałe i parametry
-# Model fizyczny
-# Inicjalizacja i reset symulacji
-# Interfejs użytkownika (Tkinter)
-# Rysowanie i animacja (Matplotlib)
-# Funkcja animate()
-# Zakończenie i pętla główna
-== 1. Opis ogólny ==
+Ten artykuł wyjaśnia, jak działa skrypt symulujący ruch masy sprężystej pod wpływem grawitacji, wiatru oraz siły tarcia, z użyciem bibliotek ''%%Tkinter%%'', ''%%Matplotlib%%'' i ''%%NumPy%%''.
-Skrypt emuluje ruch kulki („jabłuszka”) o masie $m$ poruszającej się w układzie dwuwymiarowym. Użytkownik może regulować siłę wiatru oraz współczynnik sprężystości odbicia (restitution), a także obserwować:
-* Tor ruchu
-* Wektory sił (grawitacja, wiatr, prędkość, wyniku)
-* Wykres prędkości i przyspieszenia w funkcji czasu
-* Reprezentację wektorów w układzie polarnym
-== 2. Stałe i parametry ==
-<syntaxhighlight lang="python">
-# Stałe fizyczne
-g  = 9.81       # przyspieszenie grawitacyjne [m/s²]
-m  = 0.15       # masa kulki [kg]
-e  = 0.7        # współczynnik sprężystości (restitution)
-μ  = 0.5        # współczynnik tarcia
-dt = 0.05       # krok czasowy [s]
-</syntaxhighlight>
-Parametry wykresów:
+----
-<syntaxhighlight lang="python">
-x_min, x_max = -20, 20   # granice osi X [m]
-y_min, y_max =  0, 40    # granice osi Y [m]
-velocity_scale = 0.2     # skala strzałki prędkości
-</syntaxhighlight>
-== 3. Model fizyczny ==
+===== ⚙️ Stałe fizyczne i warunki początkowe =====
-=== 3.1 Przyspieszenie ===
-Przyspieszenie kulki w kierunku poziomym i pionowym wyznaczamy z II zasady dynamiki Newtona:
-<math>
-a_x = \frac{F_\text{wiatr}}{m}, \quad
-a_y = -g
-</math>
-=== 3.2 Równania kinetyczne ===
+<code python>
-Pozycję i prędkość w kolejnych krokach obliczamy ze wzorów:
+g = 9.81              # Przyspieszenie ziemskie (m/s^2)
-<math>
+m = 0.15              # Masa piłki (kg)
-v(t+\Delta t) = v(t) + a \,\Delta t
+restitution = 0.7     # Współczynnik sprężystości (odbicia)
-</math>
+friction_coefficient = 0.5  # Współczynnik tarcia
-<math>
+</code>
-x(t+\Delta t) = x(t) + v(t)\,\Delta t + \tfrac12\,a\,\Delta t^2
-</math>
-=== 3.3 Odbicie od podłoża ===
+Używamy podstawowych stałych z fizyki:
-Gdy kulka dotyka podłoża ($y \le y_\min$), następuje odbicie:
-<math>
-v_y' = -\,e\, v_y
-</math>
-gdzie $e$ to współczynnik sprężystości. Jeżeli prędkość pionowa jest mała ($|v_y|<0.5$), dodajemy tarcie:
-<math>
+  * Siła grawitacji: ( F_g = m g )
-F_\text{tarcie} = \mu\, m\, g
+  * Odbicie piłki od ziemi następuje z redukcją prędkości pionowej przez współczynnik sprężystości: $$ v_{y, \text{po}} = -v_{y, \text{przed}} \cdot e $$
-</math>
-które zmniejsza prędkość poziomą:
-<math>
-v_x \;\to\; v_x \;-\;\mathrm{sign}(v_x)\,\mu\,g\,\Delta t
-</math>
-== 4. Inicjalizacja i reset symulacji ==
-Funkcja `reset_simulation()` przywraca początki symulacji:
-<syntaxhighlight lang="python">
-def reset_simulation():
-    global x, y, vx, vy, trace, sim_time, time_list, speed_list, acc_list
-    x, y = 0, 30         # początkowa pozycja
-    vx, vy = 0, 0        # początkowe prędkości
-    trace = []           # czyszczenie śladu toru
-    sim_time = 0.0
-    time_list = []
-    speed_list = []
-    acc_list = []
-</syntaxhighlight>
-== 5. Interfejs użytkownika (Tkinter) ==
+----
-Symulacja działa w oknie Tkinter, w którym mamy:
-* Suwak do zmiany siły wiatru (`wind_slider`)
-* Suwak do zmiany współczynnika sprężystości (`spring_slider`)
-* Przycisk „Restart” – ponowne wywołanie `reset_simulation()`
-* Pole tekstowe (`info_text`) wyświetlające bieżące wartości czasu, pozycji, prędkości, przyspieszenia i sił.
-== 6. Rysowanie i animacja (Matplotlib) ==
+===== 🧮 Obliczenia sił i przyspieszeń =====
-Tworzymy trzy wykresy:
-# Główny wykres 2D: pozycja kulki i wektory sił
-# Wykres czasowy prędkości i przyspieszenia
-# Wykres polarny wektorów
-Przykład inicjalizacji głównego wykresu:
+==== Kod: ====
-<syntaxhighlight lang="python">
-fig, ax = plt.subplots(figsize=(8, 6))
-ax.set_xlim(x_min, x_max); ax.set_ylim(y_min, y_max)
-ax.set_xlabel("X (m)"); ax.set_ylabel("Y (m)")
-apple = patches.Circle((0, 30), 0.2, color='red')
-ax.add_patch(apple)
-trace_line, = ax.plot([], [], 'r--', label='Trace')
-</syntaxhighlight>
-== 7. Funkcja animate() ==
+<code python>
-To serce animacji wywoływane przez `FuncAnimation`. W kolejnych krokach:
+Fw = wind_force
-<syntaxhighlight lang="python">
+ax_acc = Fw / m
-def animate(i):
+ay_acc = -g
-    global x, y, vx, vy, sim_time
+</code>
-    # 1) Obliczanie przyspieszeń
+Zgodnie z II zasadą dynamiki Newtona:
-    ax_acc = wind_force / m
-    ay_acc = -g
-    # 2) Aktualizacja prędkości
+  * Siła wiatru generuje przyspieszenie poziome: $$ a_x = \frac{F_{\text{wiatr}}}{m} $$
-    vx += ax_acc * dt
+  * Przyspieszenie pionowe jest równe przyspieszeniu ziemskiemu: $$ a_y = -g $$
-    vy += ay_acc * dt
-    # 3) Aktualizacja pozycji
-    x  += vx * dt + 0.5 * ax_acc * dt**2
-    y  += vy * dt + 0.5 * ay_acc * dt**2
-    # 4) Odbicie i tarcie
+----
-    if y <= y_min:
-        y = y_min
-        vy = -vy * restitution
-        # ... kod tarcia ...
-    # 5) Aktualizacja obiektu graficznego
+===== 🧠 Kinematyka ruchu =====
-    apple.set_center((x, y))
-    trace.append((x, y))
-    trace_line.set_data(*zip(*trace))
-    # 6) Rysowanie wektorów na wykresie:
+<code python>
-    g_vector.remove()
+vx += ax_acc * time_step
-    wind_vector.remove()
+vy += ay_acc * time_step
-    resultant_vector.remove()
+x += vx * time_step + 0.5 * ax_acc * time_step**2
-    g_vector = draw_arrow(x, y, 0, -1, 'blue')
+y += vy * time_step + 0.5 * ay_acc * time_step**2
-    wind_vector = draw_arrow(x, y, wind_force, 0, 'green')
+</code>
-    resultant_vector = draw_arrow(x, y, vx*velocity_scale, vy*velocity_scale, 'purple')
-    # 7) Aktualizacja wykresów prędkości i przyspieszenia
+Używamy podstawowych równań kinematyki:
-    sim_time += dt
-    current_speed = np.hypot(vx, vy)
-    time_list.append(sim_time); speed_list.append(current_speed); acc_list.append(np.hypot(ax_acc, ay_acc))
-    line_speed.set_data(time_list, speed_list)
-    line_acc.set_data(time_list, acc_list)
-    ax2.set_xlim(0, sim_time+dt)
-    ax2.set_ylim(0, max(max(speed_list,1), max(acc_list,1))*1.2)
-    data_canvas.draw()
-    # 8) Aktualizacja pola tekstowego
+$$
-    info_text.delete("1.0", tk.END)
+v = v_0 + a \cdot \Delta t \\
-    info_text.insert(tk.END, f"Time: {sim_time:.2f} s\nPosition: ({x:.2f},{y:.2f})\n…")
+s = s_0 + v \cdot \Delta t + \frac{1}{2} a \cdot \Delta t^2
+$$
-    # 9) Wykres polarny
-    polar_ax.clear()
-    draw_polar_arrow(polar_ax, -np.pi/2, m*g, 'blue', 'Grawitacja')
-    # … pozostałe wektory …
-    polar_canvas.draw()
-    return apple, g_vector, wind_vector, resultant_vector, trace_line, line_speed, line_acc
+----
-</syntaxhighlight>
+===== 🪨 Odbicie od ziemi i tarcie =====
+<code python>
+if y <= y_min:
+    vy = -vy * restitution
+    if abs(vy) < 0.5:
+        vx -= \dots \text{(siła tarcia)}
+</code>
+Siła tarcia kinetycznego:
+$$
+F_{\text{tarcia}} = \mu \cdot m \cdot g \\
+a_{\text{tarcia}} = \frac{F_{\text{tarcia}}}{m} = \mu \cdot g
+$$
+----
+===== 📈 Wektory sił i wykresy =====
+Kod rysuje wektory:
+  * Grawitacji – zawsze w dół
+  * Wiatru – poziomo
+  * Prędkości – dynamicznie
+<code python>
+draw_arrow(x, y, vx * scale, vy * scale, 'purple')
+</code>
+----
+===== 🧭 Wektory na wykresie biegunowym =====
+<code python>
+draw_polar_arrow(polar_ax, angle, magnitude, color)
+</code>
+Ten fragment przelicza wartości sił i prędkości do współrzędnych biegunowych. Dzięki temu użytkownik może obserwować ich kierunki i względne wartości.
+----
+===== 📊 Wykresy prędkości i przyspieszenia =====
+<code python>
+current_speed = np.sqrt(vx**2 + vy**2)
+net_acc = np.sqrt(ax_acc**2 + ay_acc**2)
+</code>
+Wartości te są dodawane do list i rysowane w czasie rzeczywistym.
+----
+===== 🧵 Podsumowanie =====
+Ten skrypt to przykład dynamicznej symulacji ruchu w dwuwymiarowym polu sił, uwzględniającej:
+  * Grawitację
+  * Wiatr jako siłę zewnętrzną
+  * Sprężystość przy zderzeniu z podłożem
+  * Tarcie dynamiczne przy niskiej prędkości
+Dzięki interfejsowi graficznemu użytkownik może manipulować parametrami i obserwować efekty fizyczne w czasie rzeczywistym.
-=== 7.1 Uwaga nt. funkcji draw_polar_arrow ===
-Funkcja rysuje wektor w układzie polarnym z określonym kątem $\theta$ i długością $r$, dodając znacznik strzałki oraz tekstową etykietę.
-== 8. Zakończenie i pętla główna ==
-Na końcu tworzymy animację:
-<syntaxhighlight lang="python">
-ani = animation.FuncAnimation(fig, animate, frames=300, interval=50, blit=False)
-root.protocol("WM_DELETE_WINDOW", on_closing)
-root.mainloop()
-</syntaxhighlight>
-Funkcja `on_closing()` zapewnia poprawne zakończenie pętli Tkinter i zamknięcie okna.
----
-Ten artykuł pokrywa wszystkie główne elementy skryptu: od definicji parametrów fizycznych, przez mechanikę ruchu, aż po elementy GUI i animacji. Dzięki zastosowaniu LaTeX‐owych wzorów równania są czytelne i wiernie odzwierciedlają użyte w kodzie prawa dynamiki.

Kacper's Wiki

Narzędzia użytkownika

Narzędzia witryny

Różnice

Narzędzia strony