Symulacje komputerowe zjawisk fizycznych z zakresu mechaniki

Temat: Symulacje komputerowe zjawisk fizycznych z zakresu mechaniki. 

Spis treści 

1. Wstęp................................................................................................................................................2 

2. Modelowanie obiektów (część 1).....................................................................................................4 

Okno 3D......................................................................................................................................4 

Obiekty, nazwy i atrybuty...........................................................................................................5 

Opis obiektu w VPython.............................................................................................................5 

Standardowe obiekty w VPython................................................................................................6 

Modelowanie krzywych..............................................................................................................7 

Napisy.......................................................................................................................................10 

Rysowanie wykresów................................................................................................................12 

3. Ruch pojedynczego nieodkształcalnego ciała (punktu materialnego)............................................14 

Symulacja ruchu pojedynczego nieodkształcalnego ciała (punktu materialnego)....................14 

Rzut w jednorodnym polu grawitacyjnym................................................................................16 

Statek w wodzie........................................................................................................................18 

Rzut z uwzględnieniem oporu powietrza i wiatru....................................................................22 

4. Modelowanie obiektów (część 2)...................................................................................................25 

Budowa obiektów od podstaw..................................................................................................25 

Relacjonowanie z kilku kamer jednocześnie............................................................................27 

Wykresy – znakowanie danych.................................................................................................31 

5. Ruch bryły sztywnej.......................................................................................................................32 

Wyznaczanie drogi hamowania samochodu.............................................................................32 

Ruch postępowo obrotowy na równi........................................................................................34 

Poślizg kuli przy pchnięciu techniką bilardową.......................................................................35 

6. Modelowanie obiektów (część 3)...................................................................................................37 

Obiekt zmieniający geometrię w czasie....................................................................................37 

Wykresy – tworzenie histogramu..............................................................................................40 

7. Wiele ciał w przestrzeni..................................................................................................................43 

Ruchy planet.............................................................................................................................43 

Ruch ciała wokół nieskończenie ciężkiej planety................................................................43 

Prawo pól Keplera................................................................................................................47 

Ruch ciała w polu dowolnej siły centralnej..........................................................................47 

Układ podwójny planet........................................................................................................48 

Ruch wielu planet z uwzględnianiem wzajemnego oddziaływania grawitacyjnego między 

sobą.......................................................................................................................................49 

8. Wybrane zagadnienia fizyczne.......................................................................................................52 

Sprężyny i tłumienie drgań.......................................................................................................52 

Waga..........................................................................................................................................56 

Wahadło torsyjne.......................................................................................................................57 

Zderzenia ciał z przeszkodami - zderzenie kul w przestrzeni...................................................58 

Model gazu doskonałego. ........................................................................................................66 

Symulacja odbijającej się kulki wewnątrz pudełka..............................................................66 

Symulacja zachowania się gazu doskonałego w zamkniętym naczyniu..............................68 

Kinetyczny model gazu doskonałego. .................................................................................79 

9. Zakończenie....................................................................................................................................89 

10. Bibliografia...................................................................................................................................90 

1

1. Wstęp 

Podziwiając widoki krajobrazu ze szczytów gór, nurkując w bezkresnych głębinach oceanu, 

lub spoglądając wieczorem na rozgwieżdżone niebo możemy zauważyć, że otaczający nas świat 

daje nam możliwość obserwacji i badań praktycznie nieograniczonej liczby zjawisk fizycznych. Są 

to zarówno zjawiska bezpośrednio nam dostępne i doświadczalne przez nasze zmysły na przykład 

związane z ciepłem, światłem, ruchem ciał, jak też zjawiska, które badać możemy pośrednio za 

pomocą przyrządów stanowiących niejako przedłużenie naszych zmysłów. Do tej grupy zaliczyć 

możemy zjawiska astrofizyczne obserwowane w naszej części wszechświata, jak i zjawiska 

z mikroświata atomów. 

Zgłębianiem tych zjawisk zajmują się naukowcy reprezentujący różne dziedziny nauki. 

Jedną z fundamentalnych dziedzin jest mechanika. Przedmiotem tej nauki jest badanie i opisywanie 

ruchów ciał. 

Początkowo przedmiotem zainteresowań mechaników był ruch pojedynczego, 

nieodkształcalnego ciała, które obecnie zwykło się nazywać zagadnieniem punktu materialnego. 

Zagadnienie to w naturalny sposób uogólniono na zagadnienie wielu ciał, czyli oddziałujących ze 

sobą punktów materialnych. 

Jako kolejny etap w rozwoju mechaniki należy wymienić wprowadzenie do rozważań ciał 

rozciągłych, ale sztywnych, czyli takich których kształt podczas ruchu nie ulega zmianom. 

Rozciągłość obiektu ma tu fundamentalne znaczenie a pozycja takiego ciała jest określona przy 

pomocy sześciu niezależnych parametrów. 

Jeżeli przedmiotem naszego zainteresowania będą ciała, które oprócz ruchu postępowego 

i obrotowego będą wykazywały ruchy wewnętrzne jednych części względem innych, problem ruchu 

takiego ciała ulegnie znacznym komplikacjom. Zagadnieniami tego typu zajmuje się mechanika 

ośrodków ciągłych. 

Niewątpliwie możliwości rozwiązywania wyżej wymienionych zagadnień 

z wykorzystaniem techniki komputerowej wpłynęły z kolei stymulująco na obserwowany do dziś 

intensywny rozwój teoretycznych i eksperymentalnych badań z zakresu mechaniki. Uzyskiwanie 

rozwiązań złożonych, wielowymiarowych, bardzo często nieliniowych zagadnień mechaniki, lub 

ogólniej – fizyki matematycznej, nazywa się często symulacją komputerową. Do określenia zespołu 

czynności związanych z rozwiązywaniem równań fizyki matematycznej używa się 

pojęcia - eksperyment komputerowy, aby podkreślić dodatkowo, że rozwiązanie dokonywane jest 

z wykorzystaniem komputera. 

Praca ma na celu zaznajomić czytelnika z elementarnymi zagadnieniami komputerowego 

modelowania i symulowania dynamicznych zjawisk fizycznych z zakresu mechaniki punktów 

materialnych, brył sztywnych oraz ciał stałych. Symulacje oparte są o interpretowany, obiektowy, 

wysokopoziomowy język programowania którym jest Python, a wizualizacja oparta została 

o bibliotekę graficzną Visual. 

Grafika trójwymiarowa zrobiła ogromną karierę. Trudno dziś znaleźć komputer, który nie 

byłby wyposażony w kartę graficzną z akceleratorem 3D. Nawet te najtańsze, wbudowane w płytę 

główną, dysponują ogromnymi możliwościami. Przyczyną takiego stanu rzeczy jest w dużym 

stopniu popularność gier komputerowych – nie oszukujmy się, praca z pakietem biurowym, bazą 

danych czy kompilatorem rzadko kiedy daje okazję do podziwiania realistycznych 

trójwymiarowych obrazów. No chyba, że pracujemy nad własną grą, ale w dzisiejszych czasach gry 

są tworzone przez wieloosobowe zespoły zawodowców, a prace nad nią zwykle trwają kilka lat. 

Grafikę 3D można wykorzystać do celów edukacyjnych, ale trudno jest oczekiwać, że 

nauczyciel fizyki, chcąc przeprowadzić symulację komputerową jakiegoś zjawiska, spędzi więcej 

czasu nad częścią swojego programu odpowiedzialną za grafikę trójwymiarową niż nad częścią 

2

zeczywiście dotyczącą interesującego go zjawiska. Również nie wydaje się prawdopodobne,aby 

uczeń stawiający pierwsze kroki w programowaniu napisał silnik 3D. W takich sytuacjach pomocny 

może się okazać Python. Jest to język warty poznania – sprawdza się nie tylko w nauce 

programowania, ale może się okazać niezastąpiony w codziennej pracy. Wystarczy powiedzie, że 

jest on intensywnie używany przez inżynierów z tak potężnych firm jak Google czy Industrial 

Light&Magic. 

3

2. Modelowanie obiektów (część 1) 

VPython to język Python plus graficzny moduł 3D zwany „Visual” napisany przez Davida 

Scherera. W tym rozdziale poznamy niektóre podstawowe możliwości tego modułu, pozwalające 

nam budować obiekty, nadawać im parametry (także fizyczne), oraz wprawiać je w ruch. Animacje 

te staną się w przyszłości podstawą pozwalającą modelować i symulować zjawiska fizyczne. Na 

początku jednak musimy poznać kilka podstawowych funkcji biblioteki Visual. 

Okno 3D 

Kiedy używamy VPython'a wyświetlane okno pokazuje nam obiekty w przestrzeni 

trójwymiarowej. Punkt (0,0,0) kartezjańskiego układu współrzędnych jest w centrum 

wyświetlanego okna. Dodatnie wartości współrzędnych x przebiegają w prawo, y 

przebiegają do góry, natomiast z wychodzą z płaszczyzny ekranu do użytkownika. 

Wartości x , y , i z mogą być wyrażane w dowolnych jednostkach. Okno 3D dopasuje się 

automatycznie skalując obiekty i dobierając odpowiednio zakres wyświetlanej sceny. Możemy, na 

przykład, zainicjować sferę o promieniu r=1 ⋅10 −15 m reprezentującą nukleon, lub sferę [G] 

o promieniu r=1 ⋅10 6 m przedstawiającą planetę, jednak nie ma sensu umieszczać obu tych 

obiektów w tej samej scenie. 

Wpisując poniższy skrypt używając IDLE (interactive development environment ) a następnie 

zapisując i uruchamiając go (poprzez naciśnięcie F5) zobaczyć możemy przykładowe okno 3D 

zawierające obiekty. 

from visual import * 

scene.background=(1.0,1.0,1.0) 

p=(0.0,0.0,0.0) 

strzalkax = arrow(pos=p, axis=(1,0,0), 

shaftwidth=1, color=color.red) 

strzalkay = arrow(pos=p, axis=(0,1,0), 

shaftwidth=1, color=color.green) 

strzalkaz = arrow(pos=p, axis=(0,0,1), 

shaftwidth=1, color=color.blue) 

pudelko=box(pos=vector(1.0,0.0,0.5), 

size=(1.0,0.5,0.2),color=(1.0,0.0,0.3)) 

kula=sphere(pos=vector(2.5,0.0,0.0), radius=0.6, 

color=(0.3,0.8,0.4)) 

Rysunek 1: Przykładowe obiekty 

wyświetlane w oknie 3D 

Widok wyświetlanej sceny możemy zmienić naciskając prawy przycisk myszy i przesuwając ją 

w górę, dół lub prawo, lewo. Zakres wyświetlanej sceny możemy zmienić klikając środkowym 

przyciskiem myszy i przesuwając ją w górę – zmniejszamy zakres widocznej sceny, lub w dół 

- powiększamy zakres. 

4

Obiekty, nazwy i atrybuty. 

Obiekty graficzne [G], które tworzymy, takie jak sphere lub box, są ciągle wyświetlane podczas 

gdy program jest uruchomiony. Aby móc odwołać się później do parametrów danego obiektu 

musimy nadać mu nazwę (taką jak pudelko i kula z przykładu u góry). Wszystkie obiekty 

posiadają atrybuty czyli właściwości takie jak kula.pos (pozycja kuli), kula.color (kolor kuli) i 

promień lub inne parametry rozmiarów obiektu. Jeżeli zmienimy atrybut pozycji lub koloru 

obiektu, Visual automatycznie zmieni pozycję lub kolor w oknie 3D. 

Możemy ustawiać wartości atrybutów w osobnym pliku (skrypcie służącym do definiowania 

obiektów), możemy również modyfikować atrybuty dynamicznie w trakcie wykonywania 

programu. Ponadto możemy tworzyć własne atrybuty. I tak na przykład kuli, którą nazwiemy 

„piłka”, po nadaniu parametrów takich jak pozycja czy kolor można dodać jej fizyczne atrybuty 

takie jak masa (pilka.masa) , prędkość (pilka.predkosc) lub moment bezwładności itp. 

Opis obiektu w VPython 

Poniżej znajduje się kompletny skrypt pokazujący jak stworzyć bryłę i zmieniać jej parametry. 

W tym przykładzie posłużymy się obiektem typu cylinder, który zostanie przypisany zmiennej 

bryla01. Posłuży on do dokładnego omówienia atrybutów obiektu. 

1 from visual import * 

2 scene.background=(1.0,1.0,1.0) 

3 p=(0.0,0.0,0.0) 

4 k=0.01 

5 bryla01 = cylinder(pos=(0.0,1.0,0.0),length=2.0,axis=(1,0,0)) 

6 bryla01.radius=0.3 

7 bryla01.color=(0.75,0.95,0.05) 

8 strzalkax = arrow(pos=p, axis=(1,0,0), shaftwidth=k, color=color.red) 

9 strzalkay = arrow(pos=p, axis=(0,1,0), shaftwidth=k, color=color.green) 

10 strzalkaz = arrow(pos=p, axis=(0,0,1), shaftwidth=k, color=color.blue) 

Należy się teraz małe wyjaśnienie co oznaczają 

poszczególne linie kodu. 

Linia 1. To instrukcja dla programu by wgrać do pamięci 

bibliotekę Visual. Każdy nowo napisany skrypt 

powinien zaczynać się od tej linii. 

Linia 2. W tej linii został określony kolor tła przy pomocy 

schematu R,G,B. W tym schemacie maksymalne 

wartości R,G,B to 1.0,1 .0,1.0 - kolor biały, 

kolor czarny przyjmuje minimalne wartości 

R,G,B czyli 0.0 ,0.0 ,0 .0 

Linia 3. Zmiennej p przypisujemy krotkę 3 pozycyjną [1] 

Linia 4. Zmiennej k przypisujemy wartość 0.01 

Linia 5. Tutaj zmiennej o nazwie bryla01 przypisujemy obiekt typu cylinder. W VPython 

atrybuty każdego obiektu mogą być zdefiniowane w nawiasach. Jeżeli w tym miejscu 

ominiemy jakieś atrybuty, obiektowi zostaną przypisane ich wartości domyślne. Więcej 

informcji na temat listy parametrów domyślnych dla danego obiektu można uzyskać w 

5 

Rysunek 2: Obiekt typu cylinder

podręczniku systemowym. Pierwszym określonym atrybutem jest pos (pozycja środka 

jednego końca cylindra – w naszym przypadku znajduje się w punkcie x=0.0 , 

y=1.0 i z=0.0 , czasami parametr ten bywa określany wektorem translacji i 

wówczas interpretuje się go jako przesunięcie od początku układu współrzędnych do 

punktu pos), kolejnym parametrem jest length czyli długość obiektu oraz axis czyli 

parametr określający oś na której leży obiekt. Jest to po prostu kierunek wyznaczony przez 

początek układu współrzędnych oraz axis 

Linia 6. Zmieniamy atrybut promienia obiektu bryla01 z wartości domyślnej na wartość równą 0.3 

Linia 7. Zmieniamy atrybut koloru używając schematu kolorów typu RGB (Red, Green, Blue). 

Linia 8,9 i 10 Zmiennym strzalkax, strzalkay i strzalkaz przypisujemy obiekt typu arrow 

(strzałka) , każda ze strzałek posiada inny kolor i jest skierowana wzdłuż innej osi układu 

współrzędnych 

Zatem cylinder leży wzdłuż osi x i posada długość równą 2 , więc środek drugiego końca 

cylindra znajduje się w punkcie 2.0,1.0 ,0.0 . Możemy modyfikować pozycję cylindra po tym 

jak został stworzony, zadając mu nową pozycję zauważyć możemy, że natychmiast przesunie się w 

zadane miejsce (wystarczy dopisać tekst na końcu skryptu: bryla01.pos=(0.0,3.0,0.0) ) 

Jeżeli stworzymy obiekt taki jak cylinder, lecz nie przypiszemy go zmiennej nie będziemy mogli 

zmieniać parametrów obiektu. Nie ma to znaczenia w przypadku gdy parametry obiektu nie będą 

nigdy zmieniane. 

Standardowe obiekty w VPython 

Oprócz kostek i kulek biblioteka oferuje nam jeszcze wiele kształtów takich jak stożki czy torusy 

a także pozwala konstruować krzywe z podanych punktów [G]. Wszystkie obiekty przyjmują 

parametr pos, ustawiający ich miejsce w przestrzeni. Wektor podawany jako axis pozwala ustawić 

obiekty nierównolegle do osi układu współrzędnych. Te obiekty w przypadku których ma to sens, 

pozwalają na podanie promienia radius. Wszystkie przyjmują parametr color. Pozycję obiektów 

można odczytywać i zmieniać już po ich stworzeniu, odwołując się do atrybutu pos lub do 

poszczególnych współrzędnych x,y,z: 

szescian.pos = (1.0,2.0,0.0) 

szesian.x = 1.0 

Podobnie podczas działania programu możemy dowolnie 

zmieniać wymiary obiektów (height, width, length, 

radius). Obiekty także możemy obracać, wywołując dla nich 

metodę rotate(os,kat,punkt), której podajemy kąt i oś, 

wokół której chcemy obiekt obracać (oś jest wyznaczona 

przez punkt i wektor). 

Przykładowy skrypt ilustrujący obrót obiektu: 


scene.range = 2.0 

stozek = cone(color=(0.0,0.4,1.0), radius = 0.4) 

punkt = (0.8,0.0,0.0) 

a=0.01 

b=a 

#----------------- 

6 

Rysunek 3: Animacja obrotu obiektu 

wokół wybranego punktu i wybranej osi

p=(0.0,0.0,0.0) 

k=0.01 

strzalkax = arrow(pos=p, axis=(1,0,0), shaftwidth=k, color=color.red) 

strzalkay = arrow(pos=p, axis=(0,1,0), shaftwidth=k, color=color.green) 

strzalkaz = arrow(pos=p, axis=(0,0,1), shaftwidth=k, color=color.blue) 

#----------------- 

while b

przykład moja_krzywa.pos[0] jest pozycją pierwszego punktu w moja_krzywa. 

Możemy również otrzymać krzywą bezpośrednio z listy współrzędnych [1]. Listę taką tworzymy 

podobnie jak krotkę (sekwencję) zamykając listę współrzędnych w okrągłych nawiasach. I tak na 

przykład aby narysować kwadrat wystarczy napisać: 

kwadrat = curve(pos=[(0,0),(0,1),(1,1),(1,0),(0,0)]) 

Oczywiście (1,1) jest skrótem (1,1,0). Jednakże, nie możemy mieszać ze sobą punktów 2D oraz 

3D w jednej liście. 

Krzywa posiada grubość, definiowaną poprzez parametr radius. Zatem średnica krzywej jest 

równa podwójnemu promieniowi. 

krzywa=curve(pos=[(0,0,0), (1,0,0)], radius=0.05) 

Domyślny promień krzywej wynosi 0, wtedy jest rysowana bardzo cienka krzywa. Jeżeli podamy 

bardzo małą niezerową wartość, krzywa stanie się prawie niewidoczna dlatego zaleca się używać 

wartości zero ponieważ wtedy średnica krzywej jest domyślnie równa jednemu pikselowi. 

Krzywą narysować możemy również z wygenerowanej listy punktów, w tym celu możemy 

posłużyć się funkcją arange( [start,] stop[, step]) , która zwraca sekwencję liczb. Poniżej 

przedstawiony jest fragment skryptu pozwalającego narysować sprężynę. 

# Rysowanie sprężyny 

c = curve( x = arange(0,20,0.1) ) 

c.y = sin( 2.0*c.x ) 

c.z = cos( 2.0*c.x ) 

Parametryczne rysowanie także nie powinno sprawiać problemu. Jak wspomniane było wczśniej 

niektóre atrybuty, na przykład color mogą być różne dla każdego punktu w krzywej. Kiedy 

będziemy chcieli nagle zmienić kolor krzywej, po prostu należy dodać kolejny punkt w miejscu 

zmiany koloru, lecz o innym kolorze. 


c = curve( pos=[(0,0,0), (1,0,0)], color=color.red ) 

c.append( pos=(1,1,0) ) # dodanie punktu w kolorze czerwonym 

c.append( pos=(1,1,0), color=color.blue) # ten sam punkt, lecz kolor niebieski 

c.append( pos=(0,1,0) ) # dodanie punktu w kolorze niebieskim 

Poniżej przedstawiony jest pełny skrypt obrazujący niektóre z wymienionych operacji na krzywych. 

Pierwsza krzywa (krzywa1) jest rysowana z punktów które mogą pochodzić na przykład z obliczeń, 

kolejna krzywa (krzywa2) zawiera jedynie dwa punkty w kolorze szarym. Do tak stworzonej 

krzywej dodajemy punkty przy pomocy funkcji append(). Ostatnia krzywa (krzywa3) jest 

rysowana parametrycznie. Do barwienia krzywej użyto pośrednio schematu HSV (Hue, Saturation, 

Value – barwa, nasycenie, wartość), który następnie zamieniony został na schemat RGB. 


scene.background=(1.0,1.0,1.0) 

a=(0,1,0) 

b=(1,1,0) 

c=(2,2,0) 

d=(3,2,0) 

krzywa1=curve(pos=[a,b,c,d],color=(0.5,0.5,0.5), radius=0.05) 

krzywa2=curve(pos=[(0,0,0), (1,0,0)],color=(0.5,0.5,0.5), radius=0.05) 

# dodanie punktow do krzywej 

8

krzywa2.append(pos=(2,1,0), color=color.green) 

krzywa2.append(pos=(3,1,0), color=color.yellow) 

# krzywa rysowana parametrycznie 

n = 16 # ilosc pelnych cykli (zwojow) sprezyny na jednostke dlugosci 

r = 2 # promien sprezyny :) 

rd = 0.05 # promien drutu 

krzywa3=curve(pos=[], radius=0.05) 

for i in arange(0.,1.,0.001): 

k=2*(1/(i+1)*i) 

#print k 

c=(k,1,1) 

krzywa3.append(pos=(-4+10*i,-2+i*r*cos(n*2*math.pi*i), 

i*r*sin(n*2*math.pi*i)), color=color.hsv_to_rgb(c)) 

#----- uklad trzech strzalek 

strzalkax = arrow(pos=(-2,-2,-2), axis=(1,0,0), shaftwidth=1, color=color.red) 

strzalkay = arrow(pos=(-2,-2,-2), axis=(0,1,0), shaftwidth=1, color=color.green) 

strzalkaz = arrow(pos=(-2,-2,-2), axis=(0,0,1), shaftwidth=1, color=color.blue) 

#----- 

Jednym z wielu sposobów zastosowania 

krzywych jest wizualizacja trajektorii 

punktu materialnego lub specyficznych 

aspektów ruchu bryły sztywnej. Kolejny 

skrypt przedstawia animację kuli 

poruszającej się w przestrzeni. Za każdym 

razem gdy kula podąża w kierunku 

rosnących wartości y do krzywej 

(trajectory) jest przypisywany punkt o 

współrzędnych równych położeniu kuli. 

Zatem poruszająca się kula pozostawi za 

sobą ślad w postaci krzywej. Dodatkowo na 

płaszczyznach xy, yz, oraz zx są rysowane 

rzuty tej trajektorii. 


#scene.background=(1.0,1.0,1.0) 

scene.range = 3.0 

Rysunek 4: Wizualizacja krzywych. 

rc=0 # promien krzywych 

col=(0.1,0.7,0.7) 

trajectory=curve(pos=[],color=col, radius=rc) #trajektoria kuli xyz 

c1=curve(pos=[],color=(0.8,0.5,0.1), radius=rc) #rzut na plaszczyzne xy 

c2=curve(pos=[],color=(0.2,0.6,0.2), radius=rc) #rzut na plaszczyzne yz 

c3=curve(pos=[],color=(0.9,0.1,0.9), radius=rc) #rzut na plaszczyzne zx 

a=1.0 

b=1.0 

c=0.0 

kula=sphere(pos=vector(a,c,b), radius=0.05, color=col) 

#p1,p2,p3 - prowadnice 

szary=(0.7,0.7,0.7) 

p1=curve(pos=[(kula.pos),(kula.pos[0],kula.pos[1],0.0)],color=szary, radius=rc) 

p2=curve(pos=[(kula.pos),(kula.pos[0],0.0,kula.pos[2])],color=szary, radius=rc) 

p3=curve(pos=[(kula.pos),(0.0,kula.pos[1],kula.pos[2])],color=szary, radius=rc) 

r = 0.6 # promien okregu 

#----- uklad trzech strzalek 

p=(0.0,0.0,0.0) 

k=0.01 

strzalkax = arrow(pos=p, axis=(1,0,0), shaftwidth=k, color=color.red) 

9

strzalkay = arrow(pos=p, axis=(0,1,0), shaftwidth=k, color=color.green) 

strzalkaz = arrow(pos=p, axis=(0,0,1), shaftwidth=k, color=color.blue) 

#----- 

n=0 

f=5 # ilosc cykli do pokonania 

i=0.0 

while nn: 

kula.pos=(a,c,b) 

i=0.0 

c1.pos=[] 

c2.pos=[] 

c3.pos=[] 

trajectory.pos=[] 

Rysunek 5: Trajektoria punktu 

materialnego poruszającego się w 

przestrzeni. 

Napisy 

W obiektach typu label możemy wyświetlać tekst. 

Tekst ten umieszczony jest w ramce, która z kolei 

jest połączona linią z wyznaczonym przez nas 

punktem. 

Na dołączonym skrypcie obiekt typu sphere 

reprezentuje Ziemię. Pozycja obiektu tekstowego 

jest równa pozycji kuli. Gdziekolwiek będzie 

umieszczona kula, podąży za nią etykietka z 

napisem „Ziemia”, oprócz tego długość linii 

(parametr line) jest tak dobrana, ze kończy się na 

powierzchni kuli. 

Rysunek 6: Diagram przedstawiający parametry 

obiektu typu label. 

10

ziemia=sphere(pos=vector(1.5,0.0,0.0), radius=0.6, color=(0.3,0.6,0.9)) 

napisZiemia = label(pos=ziemia.pos, text='Ziemia',color=(0.7, 0.2, 0.7), 

xoffset=20, yoffset=16, space=ziemia.radius, 

height=28, border=6,linecolor=(1.0, 0.0, 0.2), 

opacity=0.3,font="Arial Black") 

Unikalne cechy tego obiektu pozwalają nam kontrolować parametry tekstu wyrażone w pikselach 

niezależnie od parametrów sceny. I tak na przykład, wysokość tekstu jest podawana w pikselach, 

niezależnie od tego jaki będzie zakres sceny (powiększenie) oraz orientacja kamery w przestrzeni, 

wysokość tekstu pozostanie niezmienna oraz zwrócona zawsze w kierunku kamery. Cecha ta 

sprawia, że napis pozostaje czytelny niezależnie od tego jak daleko znajduje się od kamery (pod 

warunkiem, że będzie umieszczony w polu widzenia kamery). 

Oto pozostałe atrybuty obiektu tekstowego: 

pos; x,y,z 

punkt rozpoczynający rysowanie etykietki z tekstem 

xoffset, yoffset składowe x oraz y parametru line wyrażone w pikselach (patrz diagram) 

text 

height 

color 

tekst który będzie wyświetlany, na przykład „Ziemia” 

(Istnieje możliwość wyświetlania napisów w kilku liniach. W tym celu jako 

znak enter używa się napisu „\n” na przykład 

label.text=”Trzy\nlinie\ntekstu”) 

wysokość tekstu wyrażona w pikselach 

kolor tekstu 

opacity nieprzezroczystość tła parametru box, domyślna wartość wynosi 0.66 

border 

box=1 

line=1 

linecolor 

space 

font 

(0 całkowicie przezroczysty, 1 nieprzezroczysty, dlaobiektów znajdujących 

się za box) 

odległość tekstu od otaczającej ramki wyrażona w pikselach 

jeżeli box powinien być rysowany (wartość ta jest przyjmowana domyślnie), 

w innym przypadku 0 

jeżeli linia od box do pos powinna być rysowana (wartość domyślna), 

w innym przypadku należy podać wartość 0 

kolor linii line oraz ramki otaczającej tekst (box) 

odległość o promieniu równym space od punktu pos wokół którego linia 

łącząca box i pos nie jest rysowana 

Dodatkowy parametr charakteryzujący rodzaj czcionki jaką ma być 

wyświetlany napis, na przykład „Arial Black”. Podawanie tego parametru nie 

jest obowiązkowe. 

11

Rysowanie wykresów 

Ważnym elementem przy analizowaniu dużych ilości danych jest możliwość umieszczenia 

wyników, na przykład pochodzących z symulacji, na wykresach. W tym paragrafie zostanie opisane 

w jaki sposób dane umieścić na wykresach 2D ( two-dimensonal). 

Importując moduł graficzny visual.graph otrzymujemu dostęp do wszystkich obiektów biblioteki 

Visual a także dostęp do modułu odpowiedzialnego za rysowanie wykresów [G]. 

from visual.graph import * # import modułu odpowiedzialnego za rysowanie 

wykresów 

Istotną cechą tego modułu jest możliwość automatycznego skalowania wykresów. Powoduje to, że 

zarówno skala na osiach rzędnych i odciętych a także zakres ich wartości mogą być dobierane 

automatycznie bez ingerencji z zewnątrz. Wykres jest zatem dopasowany do rozmiarów okna w 

którym jest wyświetlany. Można to zaobserwować uruchamiając poniższy skrypt. 


from visual.graph import * # import modulu rysujacego wykresy 

funkcja_1 = gcurve(color=(0.1,0.9,0.1)) 

for x in arange(0., 10.1, 0.01): # x przebiega wartosci od 0 do 10 

funkcja_1.plot(pos=(x,3*cos(1.2*x) + sin(20.*x))) 

Połączenie poszczególnych punktów pomiarowych przy pomocy łamanej (gcurve) jest tylko 

jednym z kilku rodzajów rysowania wykresów. Inne opcje to punkty rozrzucone bezładnie (gdots), 

pionowe słupki (gvbars), poziome słupki (ghbars), oraz dane posortowane i powiązane ze sobą 

jako pionowe słupki tzw. histogramy. 

Kiedy tworzymy jeden z tego typu obiektów, możemy wyszczególnić kolor jakim ma być rysowany 

wykres. Dla pionowych i poziomych słupków możemy również określić tak zwany parametr 

„delta” czyli po prostu szerokość słupka (wartością domyślną jest delta=1) 

Istnieje możliwość rysowania więcej niż jednego wykresu w jednym oknie: 


from visual.graph import * # import modulu rysujacego wykresy 

funkcja_1 = gcurve(color=(0.1,0.9,0.1)) 

funkcja_2 = gvbars(delta=0.03, color=(0.9,0.1,0.5)) 


funkcja_1.plot(pos=(x,3*cos(1.2*x) + sin(20.*x))) #curve 


funkcja_2.plot(pos=(x,cos(x) + sin(x))) # vbars 

Wykresy typu gcurve, gdots, gvbars, lub ghbars można tworzyć na podstawie gotowych list 

punktów, które możemy nanosić na wykres. Listy mają strukturę identyczną, z tą z którą mieliśmy 

do czynienia w przypadku tworzenia obiektów typu curve. 

punkty = [(0,0), (1,2),(2.5,4), (5,2.1), (7,-3)] 

data=gdots(pos=punkty, color=(1.0,0.0,0.5)) 

Ogólne opcje obiektów typu gdisplay. 

Możemy ustalać rozmiar wykresu, pozycję wyświetlania na monitorze, tytuł na belce stanu 

wykresu, tytuły dla każdej z osi układu współrzędnych, specyficzne wartości takie jak minimum 

12

i maksimum dla każdej z osi. 

bbs=0 

if bbs==1: 

pierwszoplanowy=(0.2,0.0,0.6)#kolor tekstu 

drugoplanowy=(1.0,1.0,1.0)#kolor tla 

else: 

pierwszoplanowy=(1.0,1.0,0.0) 

drugoplanowy=(0.0,0.0,0.0) 

wykres_a_graph = gdisplay(x=0, y=0, width=656, height=400, 

title='y=sin(x)', xtitle='x', ytitle='sin(x)', 

xmax=15.0, xmin=-1.0, 

ymax=1.5, ymin=-1.5, 

foreground=pierwszoplanowy, 

background=drugoplanowy) 

W tym przykładzie, okno wykresu będzie ulokowane w punkcie (0,0), jego rozmiar będzie wynosić 

656 (szer.) na 400 (wys.) pikseli, tytuł na belce stanu to „y=sin(x)”. Wykres ma nadaną nazwę dla 

osi odciętych „x” oraz dla osi rzędnych „sin(x)”. Zamiast automatycznego skalowania zakresu dla 

wszystkich danych, wykres posiada ograniczenia dla obu osi. I tak zakres dla osi poziomej rozciąga 

się w granicach od -1 do +15, a dla osi pionowej od -1,5 do +1,5. Kolor napisów jest żółty 

(domyślna wartość to kolor biały) a kolor tła - czarny (domyślna wartość – czarny). Jeżeli po prostu 

napiszemy gdisplay(), domyślnymi wartościami będą x=0, y=0, width=800, height=400, bez 

tytułu z pełnym auto-skalowaniem zarówno dla osi x jak i y. 

Ponadto tak jak każdy obiekt VPythona, wykres posiada atrybut visible. Przypisanie wartości 

moj_wykres.display.visible=0 sprawi, że wykres będzie niewidoczny. 

Oprócz tego możemy mieć więcej niż jedno okno typu gdisplay a w każdym oknie więcej niż jeden 

typ wykresu. W tym celu należy wywołać funkcję inicjującą wykres a następnie kolejno określać 

jakie typy wykresów mają być rysowane w poszczególnych oknach. 

13

3. Ruch pojedynczego nieodkształcalnego ciała (punktu 

materialnego) 

Symulacja ruchu pojedynczego nieodkształcalnego ciała (punktu 

materialnego) 

Umiejętność przewidywania odpowiedzi układu dynamicznego w wyniku oddziaływania 

z zewnątrz jest niezbędna przy wykonywaniu symulacji fizycznych. Wynika stąd potrzeba 

rozwiązywania (całkowania) równań różniczkowych. W tym rozdziale rozpatrywane będą 

numeryczne metody rozwiązywania tzw. zagadnienia początkowego (zagadnienia 

Cauchy'ego)[10],[11], to jest wyznaczaniem funkcji y 1 

t , ... , y M 

t , spełniających dla 

t∈[t 0 

,t 0 

T ] układ równań różniczkowych: 

dy m 

t 

= f 

dt m 

t , y 1 

,... , y M 

t dla m=1, ... , M 

z warunkami początkowymi: 

y 1 

t 0 

= y 1,0 

,... , y M 

t 0 

= y M ,0 

W zapisie wektorowym układ ten ma postać: 

y ' t= f t , yt , yt 0 

= y 0 gdzie yt =[ y 1 

t... y M 

t ] T . 

W fizyce zmienna niezależna t ma zazwyczaj sens czasu, natomiast funkcje y m 

t 

reprezentują na przykład zmienne w czasie ładunki, napięcia, siły itp. Zagadnienie początkowe 

można więc interpretować jako wyznaczenie odpowiedzi czasowej układu dynamicznego w czasie 

[t 0 

,t 0 

T ] . Najprostszą metodę rozwiązywania zagadnienia początkowego można uzyskać 

poprzez przybliżenie pochodnej za pomocą różnic skończonych. Taką metodą jest otwarta metoda 

Eulera: 

y n1 

= y n 

h f t n 

, y n 

, y 0 

= y t 0 

 

Pierwsza pochodna funkcji, wyznacza kierunek 

położenia nowego punktu rozwiązania czyli tak 

zwany predyktor. Odległość między predyktorem 

a rozwiązaniem dokładnym stanowi błąd tej 

metody. Metoda Eulera jest łatwa do 

zastosowania i dobrze oddaje charakter 

rozwiązania, ale często 

jest obarczona dużym błędem. W analizie 

numerycznej wyróżniane są zasadniczo dwa typy 

błędów. Jedne wynikające z wykonywania 

działań arytmetycznych tak zwane błędy 

zaokrągleń oraz drugie wynikające z 

dyskretyzacji (obcięcia) nazywa się je błędem 

metody. W przypadku obliczeń prowadzonych w 

języku Python mamy standardowo do czynienia z Rysunek 7: Graficzna interpretacja metody Eulera. 

podwójną precyzją obliczeń 1 , więc błędy 

1 Jest tak w przypadku obliczeń z użyciem liczb zmiennoprzecinkowych, natomiast w przypadku obliczeń 

prowadzonych na obiektach typu wektor dokładność jest pojedyncza. 

14

zaokrągleń niewiele wpływają na wynik obliczeń. Istotnym czynnikiem może jednak być błąd 

obcięcia związany z zastosowaną metodą. Zobaczmy jak duży jest ten błąd dla metody Eulera. 

Każdą funkcję można przedstawić za pomocą rozwinięcia w szereg Taylora. 

y i1 

= y i 

y i 

' h y ' ' i 

2 ! h2 ... y n 

i 

n ! hn R n 

gdzie R n 

= y n1 

i 

n1! hn1 przy czym h=x i1 

– x i oraz x i x i1 

y i1 

= y i 

f x i 

, y i 

h[ f ' x i , y i h 2 

... f n−1 x i , y i h n 

0⋅h n1 

2! 

n! 

] 

Z poprzedniego równania widać, że błąd obcięcia wynosi 

E t 

= f ' x , y i i h2 

...0⋅h n1 

2 ! 

a gdy błąd przybliżamy do pierwszego wyrazu błędu obcięcia: 

E t 

= f ' x i , y i h 2 

2 ! 

Jest to błąd lokalny na jednym kroku proporcjonalny do kwadratu kroku. Można też wykazać, że 

błąd globalny (całkowity) jest proporcjonalny do pierwszej potęgi kroku. 

Zobaczmy jak będzie wyglądała 

implementacja powyższej metody dla 

punktu materialnego umieszczonego 

na równi pochyłej. Dla takiego 

punktu druga zasada dynamiki 

przyjmie postać: 

F c 

F s 

=ma 

zatem po rozpisaniu na składowe 

otrzymamy 

m ẍ=m g sin 

m ÿ=m g cos 

W klasycznej metodzie Eulera 

położenie otrzymujemy przez dodanie 

Rysunek 8: Siły działające na punkt materialny umieszczony na równi 

pochyłej. 

przedziału czasu mnożonego przez 

prędkość. Tylko, że prędkość na początku przedziału jest inna niż na końcu, więc algorytm taki 

należy poddać niewielkiej modyfikacji. Usprawnienie polega na podstawianiu do algorytmu, 

prędkości ze środka przedziału. Gdy prędkość się zmienia i wiemy jaka jest w chwili czasu t to 

stosując tę wartość nie otrzymamy poprawnego wyniku w czasie tdt . Analogicznie 

postępujemy w przypadku obliczania prędkości biorąc przyspieszenie w połowie przedziału między 

dwiema chwilami w których obliczamy prędkość. 

Stosując zmodyfikowaną metodę Eulera [7] otrzymamy 

xtdt=x tdt v x 

dt 

t 

2 

v x 

dt 

t 

2 x =v dt 

t− 

2 dt at 

a x t=g sin 

a prędkość pośrednia dla chwili początkowej 

v x dt 

2 =v t x 0 dt 

2 a t x 0 

w analogiczny sposób wyznaczamy przyspieszenie, prędkość i położenie dla y-owej składowej. 

15

Przy pomocy powyższych równań została skonstruowana funkcja Modify_Euler() odpowiedzialna 

między innymi za całkowanie równań ruchu. W celu sprawdzenia wyników symulacji może zostać 

uruchomiona funkcja dane_precyzyjne(). Opiera się ona o następujące równania. Przyspieszenie 

jest wyliczane na podstawie znanego wzoru a=g sin ig cos j , prędkość ciała określa 

zależność v= g sin t i g cost j , oraz położenie 

2 

r= x g sin t 

0 2 j . 

Wzory te są prawdziwe przy założeniu zerowej prędkości początkowej. 

2 i y 0 g cost 2 

Rysunek 9: Symulacja ruchu punktu materialnego umieszczonego na równi pochyłej. Kolorem czerwonym 

przedstawione zostały wyniki symulacji, natomiast kolorem zielonym wartości teoretyczne. Całkowanie - metoda Eulera 

Rzut w jednorodnym polu grawitacyjnym 

Z zagadnieniem ruchu w przestrzeni dwu- lub trójwymiarowej [3],[6],[8],[9] łączy się wiele 

problemów, z którymi mamy do czynienia w życiu codziennym. Na przykład siły działające na 

ciało w czasie rzutu ukośnego są bardzo podobne do tych, które działają na samoloty, samochody i 

wszelkie inne obiekty poruszające się w wodzie, powietrzu i na lądzie. 

Przy pominięciu efektów aerodynamicznych, jedyna siła jaka działa na ciało które rzucimy, jest siła 

grawitacji. Jeżeli rzut jest wykonywany ze stosunkowo niewielkimi prędkościami (czyli trajektoria 

ciała przebiega na niedużych wysokościach i w odpowiednio krótkim czasie) możemy pominąć 

16

efekt Coriolisa oraz przyjąć stałe przyspieszenie. Symulację rzutu uwzględniającego wspomniany 

efekt Coriolisa można znaleźć na stronie [D] 

Kolejnym uproszczeniem jakie zostało przyjęte przy konstruowaniu symulacji rzutu jest płaskość 

powierzchni Ziemi to znaczy jej krzywizna jest dużo większa w porównaniu z zasięgiem rzuconego 

ciała. Dodatkowo aby porównać wyniki symulacji w wartościami wyliczonymi zostały 

zaimplementowane funkcje pozwalające między innymi na obliczenie zasięgu 

R= 2v 2 0 

sin cos 

, 

g 

czasu trwania lotu t lotu 

= 2v 0 sin 

, 

g 

oraz maksymalnej wysokości osiąganej przez ciało h= v 2 0 sin 2 

2 g 

. 

Rysunek 10: Symulacja rzutu ukośnego na płaskiej powierzchni w stałym polu grawitacyjnym. Jedna z opcji programu 

pozwala na wizualizację wypadkowego wektora prędkości oraz jej składowych. 

Jak widać na powyższej ilustracji trajektoria ciała jest krzywą paraboliczną, na szczycie trajektorii 

składowa pionowa przyjmuje wartość równą zeru, a wartość prędkości w chwili wyrzucenia ciała 

jest równa wartości prędkości w chwili upadku na ziemię. Symetria zagadnienia pozwala także 

zauważyć, że czas dotarcia ciała do najwyższego punktu trajektorii jest równy czasowi spadania. 

Ponadto przy większej liczbie prób można zauważyć iż maksymalny zasięg otrzymujemy gdy 

w chwili wyrzucenia składowa x-owa jest równa składowej y-owej. 

17

Statek w wodzie 

Kolejny przykład to ruszanie z miejsca statku [3]. Łódź taka najpierw pozostaje w spoczynku, 

a następnie śruba zaczyna się obracać i wytwarzać pchającą go siłę T nazywaną często siłą ciągu 

silnika. Zakładając, że siła jest niewielka, siłę oporu możemy w przybliżeniu wyrazić następująco: 

R=−C v gdzie 

R - jest oporem całkowitym. 

Pierwszym krokiem rozwiązania jest identyfikacja wszystkich sił działających na statek. 

Zagadnienie znacząco się upraszcza gdy 

siła wyporu będzie równa ciężarowi, a 

statek nie będzie ulegał chwilowym 

zanurzeniom i wynurzeniom z wody, wtedy 

będziemy mieli do czynienia z ruchem 

jednowymiarowym wzdłuż osi x-ów. 

Zgodnie z drugą zasadą dynamiki Newtona 

można napisać: 

∑ F x 

=m a 

T −C v=m a 

Rysunek 11: Siły działające na statek. 

gdzie T - jest siłą ciągu silnika, C - współczynnik oporu cieczy, v - prędkość statku 

podstawiamy a= dv i przekształcamy 

dt 

v 

m 

dt=∫ 

T −C v ] dv 

t 

∫ [ 

0 0 

Scałkowanie tego równania po czasie pozwala na otrzymanie szybkości statku w funkcji czasu. 

W efekcie otrzymamy: 

v 2 

= T C − T 

C 

1 C m −v t 

e− 

następnie podstawiamy v= ds 

dt 

t 

∫ 

0 

[ T C − T C −v 1 e− 

C m t] t 2 

dt= ∫ds 

t 1 

i przekształcamy 

ponowne scałkowanie pozwala na wyznaczenie przesunięcia statku w funkcji czasu: 

s 2 

=s 1 

 

T C t T C −v 1 m C e− 

C m t − 

T C −v 1 m C 

Równania określające szybkość i przemieszczenie w funkcji czasu służą kontroli precyzji 

otrzymywanych wyników symulacji. 

18

Rysunek 12: Symulacja ruchu punktu materialnego w jednym wymiarze z uwzględnieniem oporu ruchu 

(proporcjonalnego do prędkości). Kolorem czerwonym przedstawione zostały wyniki symulacji, natomiast kolorem 

zielonym wartości teoretyczne. Całkowanie – metoda Rungego-Kutty. 

Aby zapewnić większą precyzję obliczeń często zmniejsza się krok czasowy symulacji jednak tylko 

w nielicznych sytuacjach zabieg taki przynosi oczekiwane rezultaty. Istnieje wiele innych metod 

zapewniających zwiększenie precyzji przy zachowaniu tego samego kroku czasowego. 

Przedstawione poniżej metody (rzędu drugiego) [10] wymagają w każdym kroku czasowym 

obliczenia dwóch wartości funkcji f : 

• metoda Heuna 

y i1 

= y i 

1 2 k 1 1 

2 

2 k h 

k 1 

= f x i 

, y i 

 

k 2 

= f x i 

h ; y i 

k 1 

h 

• metoda punktu środkowego (ang. mid-point method) 

y i1 

= y i 

k 2 

h 

k 1 

= f x i 

, y i 

 

k 2 

= f 

x i 1 2 h ; y i 1 2 k 1 h 

19

y i1 

= y i 

1 3 k 2 1 

3 

2 k h 

• metoda Ralston'a zapewniająca mniejszy błąd obcięcia 

k 1 

= f x i 

, y i 

 

k 2 

= f 

x i 3 4 h; y i 3 4 k 1 h 

Kolejna metoda zapewnia jeszcze większą dokładność. Jest ona znana pod nazwą metody Rungego- 

Kutty . Odpowiadająca jej funkcja f ma postać: 

t , y ,h=∑ w r 

k r 

r =1 

przy czym: 

R 

k r 

=k r 

t , y ,h= f tha r 

, y∑ b r , 

k 

dla r=1,... , R 

R 

=1 

zaś a r , b r , , w r są parametrami. Jeżeli b r , 

=0 to metoda jest typu otwartego (ang.: 

explicit). W przeciwnym wypadku metoda jest typu zamkniętego (ang.: implicit). Wyznaczenie 

wartości funkcji t , y , h wymaga wówczas rozwiązania równań nieliniowych ze względu na 

k r . Maksymalny rząd otwartej metody Rungego-Kutty, korzystającej z R wartości funkcji 

wynosi pR , przy czym p=R dla R=1,2 ,3 ,4 . Maksymalny rząd metody Rungego- 

Kutty może być równy 2 R , jednakże ze względu na konieczność rozwiązywania nieliniowych 

równań algebraicznych koszt wykonana jednego kroku jest dla takiej metody na ogół znacznie 

większy niż dla odpowiedniej metody otwartej. 

Najczęściej stosowana jest metoda Rungego-Kutty czwartego rzędu ze współczynnikami [11]: 

w 1 

=w 4 

= 1 , w 

6 

2 

=w 3 

= 1 3 

k 1 

= f t , y , k 2 

= f th /2 , yh k 1 

/2 

k 3 

= f th/2 , yh k 2 

/2 , k 4 

= f t , yh k 3 

y i 1 

= y i 

1 6 k 1 

2k 2 

2k 3 

k 4 h 

oraz metoda Rungego-Kutty rzędu trzeciego: 

k 1 

= f x i 

, y i 

 

k 2 

= f 

x i 1 2 h; y i 1 2 k 1 h 

k 3 

= f x i 

h; y i 

−k 1 

h2 k 2 

h 

y i 1 

= y i 

1 6 k 1 

4k 2 

k 3 h 

20

Tabela. Wyniki symulacji dla ruchu punktu materialnego w jednym wymiarze z uwzględnieniem 

oporu ruchu (proporcjonalnego do prędkości) plik 04ruch1D_w_cieczy.py 

Eulera 

Heuna 

Mid-point 

Ralston'a 

Metoda 

Rungego-Kutty III 

Rungego-Kutty IV 

Wartość precyzyjna 

Eulera 

Heuna 

Mid-point 

Ralston'a 




Eulera 

Heuna 

Mid-point 

Ralston'a 




Eulera 

Heuna 

Mid-point 

Ralston'a 




czas 

[s] 

10 

20 

50 

100 

przyspieszenie 

[m/s^2] 

prędkość 

[m/s] 

położenie 

[m] 

0.739459275299 12.679353174535 74.474403572099 

0.735734079146 12.642287625676 74.206061670345 

0.739449907828 12.642287625676 74.206061670345 

0.737591993487 12.642287625676 74.206061670345 

0.735796132966 12.642411485600 74.206957495689 

0.735758820166 12.642411175953 74.206955256137 

0.735758882343 12.642411176571 73.575888234288 

0.270666009814 17.320406502841 228.527975621877 

0.270665986917 17.293203430836 227.928280837193 

0.272032986851 17.293203430836 227.928280837193 

0.271349486884 17.293203430836 227.928280837193 

0.270684258843 17.293294562639 227.930285259632 

0.270670543622 17.293294334813 227.930280248621 

0.270670566473 17.293294335268 227.067056647323 

0.013273703116 19.868590339152 803.30095564239 

0.013476344869 19.865229745070 802.335972772794 

0.013544407217 19.865229745070 802.335972772794 

0.013510376043 19.865229745070 802.335972772794 

0.013476574003 19.865241088319 802.339204080840 

0.013475892864 19.865241059962 802.339196002693 

0.013475893998 19.865241060018 801.347589399826 

0.000087214641 19.999136575052 1802.008547906987 

0.000090810522 19.999091848919 1801.004011205801 

0.000091269161 19.999091848919 1801.004011205801 

0.000091039841 19.999091848919 1801.004011205801 

0.000090804422 19.999092001786 1801.007376393834 

0.000090799852 19.999092001404 1801.007367981006 

0.000090799860 19.999092001405 1800.009079985924 

Nazwa Rungego-Kutty III odnosi się do metody Rungego-Kutty trzeciego rzędu, natomiast metoda Rungego-Kutty IV odnosi się do tej samej 

metody rzędu czwartego. 

Symulacja była wykonana dla następujących parametrów początkowych: masa statku m=10000.0 kg, współczynnik oporu C = 1000.0 kg/s, siła 

ciągu silnika T=20000.0 N,krok czasowy symulacji dt=0.1 s 

21

Rzut z uwzględnieniem oporu powietrza i wiatru. 

W poprzedniej symulacji rzutu dokonane zostały uproszczenia polegające między innymi na 

pominięciu oporu powietrza. W praktyce jednak jest to tylko możliwe w przypadku gdy ciało 

porusza się w próżni. Kolejnym uproszczeniem było przyjęcie braku wiatru mogącego znosić ciało. 

Uwzględnienie ich w kolejnej symulacji sprawia, że trajektoria lotu staje się bardziej realistyczna 

i jest zbliżona do tych z którymi mamy do czynienia w przypadkach ciał poruszających się 

w atmosferze [3]. Niemniej jednak i i tym przypadku zostały poczynione pewne założenia 

upraszczające równania ruchu. Po pierwsze założone zostało, że ciało jest kulą a siła oporu 

powietrza jest proporcjonalna do prędkości ze stałym współczynnikiem proporcjonalności. Co 

przedstawić możemy w postaci: 

F d 

=−C d v gdzie C d jest współczynnikiem oporu powietrza. 

W rzeczywistości jednak siła oporu jest jednak funkcją kwadratu szybkości. Takie założenie sprawi, 

że otrzymamy rozwiązania analityczne. Po drugie założone zostało, że na ciało działa wiatr o stałej 

sile zależnej od stałego współczynnika oporu i szybkości wiatru: 

F w 

=−C w v w . 

Znak minus oznacza że siła jest przeciwnie zwrócona do ruchu ciała gdy wiatr wieje w kierunku 

przeciwnym niż porusza się ciało. Można zatem zapisać składowe x i y siły wiatru w zależności od 

jego kierunku: 

F wx =F w cos =−C w v w cos 

F wz =F w sin =−C w v w sin 

Równania ruchu dla każdej z osi układu 

współrzędnych przyjmą postać: 

∑ F x 

=F wx 

F dx 

=m a x 

∑ F y 

=F dy 

F g 

=ma y 

∑ F z 

=F wz 

F dz 

=m a z 

Na początek podstawiamy do równań ruchu 

wyrażenia odpowiadające działającym siłom: 

−C w 

v w 

cos−C d 

v x 

=m dv x 

dt 

−C d 

v y −mg=m dv y 

dt 

−C w 

v w 

sin −C d 

v z 

=m dv z 

Rysunek 13: Wyznaczenie kąta gamma. 

dt 

W oparciu o te równania skonstruowana jest funkcja metoda_EULERA() odpowiedzialna za 

wyznaczanie prędkości i położenia w kolejnych chwilach czasu. By móc kontrolować otrzymane 

wyniki musimy poddać całkowaniu te równania i wówczas otrzymamy: 

dla składowych x 

v x2 

= 1 

C d 

[e − C d 

m t C w 

v w 

cos C d 

v x1 −C w 

v w 

cos] 

s x 2 

={ m C d 

 

C d 

e− 

m t[ C v cos 

w w 

C d 

−v 1] 

x 

[ − C v cos 

w w 

C d 

]} { t − m [ C d 

− C v cos 

w w 

C d 

−v 1]} 

x s x 1 

22

dla składowych y 

v y2 

= 1 C d 

 

{ 

s y2 

=s − y1 

[ v y 1 

mg 

C d 

e− 

m t C d 

v y 1 

mg − mg 

C d 

C d 

] 

m 

C d 

C d 

e− 

m t −t mg 

} C d 

{ m C d 

[ 

v y 1 

mg 

C d 

]} 

dla składowych z 

v z2 

= 1 

C d 

[e − C d 

m t C w 

v w 

sin C d 

v z1 −C w 

v w 

sin ] 

s z 2 

={ m C d 

[ − C v w wsin 

C d 

C d 

e− 

m t[ C v w wsin 

C d 

−v 1] 

z 

t ]} − { m C d 

[ 

− C v w wsin 

C d 

−v 1]} 

z s z 1 

i tak jak poprzednio równania te stają się elementami funkcji pozwalającej ocenić dokładność 

rozwiązania numerycznego. 

23

Rysunek 14: Symulacja ruchu punktu materialnego w trzech wymiarach z uwzględnieniem oporu ruchu 

(proporcjonalnego do prędkości) oraz wiatru (o stałej prędkości i kierunku). Kolorem czerwonym przedstawione 

zostały wyniki symulacji, natomiast kolorem zielonym wartości teoretyczne. Całkowanie - metoda Eulera 

24


Budowa obiektów od podstaw 

• metoda frame 

Jedną z najprostszych metod tworzenia obiektów złożonych jest łączenie brył prymitywnych 

w większe grupy [G]. Przy pomocy funkcji frame możemy łączyć ze sobą zarówno różne 

bryły jak i krzywe, budując w ten sposób większe i bardziej złożone elementy. Połączone 

w ten sposób obiekty można przesuwać i obracać tak jak pojedyncze obiekty. 

magnes=frame() 

box(frame=magnes,pos=(0.0,0.0,0.0), 

length=1.0,height=0.25,width=0.25, 

color=(1.0,0.0,0.0)) 

box(frame=magnes,pos=(1.0,0.0,0.0), 

length=1.0,height=0.25,width=0.25, 

color=(0.2,0.2,1.0)) 

while 1: 

rate(25) 

#magnes.axis = (1,1,0) 

magnes.rotate(axis=(0,0,1), angle=a, 

origin=punkt) 

Domyślnie funkcja frame() przyjmuje pozycję 

(0,0,0) i orientację wzdłuż kierunku osi x. Gdy 

zmienione zostaną atrybuty funkcji frame() na 

przykład pozycji lub obrotu, cały obiekt zostanie 

przesunięty i obrócony. 

• funkcja convex 

Kolejna metoda umożliwia tworzenie obiektów na podstawie listy wierzchołków [G]. 

Funkcja convex() pobiera listę pozycji punktów, 

(podobnie jak funkcja curve() ) z których generuje obiekt 

wypukły. Jeżeli się zdarzy, że któryś z punktów będzie 

leżał wewnątrz obiektu wypukłego to zostanie on 

pominięty. W przypadku gdy punkty będą leżeć w jednej 

płaszczyźnie utworzony obiekt będzie płaską 

powierzchnią. Poniżej przedstawiony został fragment 

skryptu przy pomocy którego można wykonać trójkąt 

równoboczny. 

Rysunek 15: Obiekty połączone przy pomocy 

funkcji frame. 

# trojkat 

POZ_x = -1.0 

POZ_y = 1.0 

POZ_z = 0.0 

Rysunek 16: Obiekty wykonane za 

trojkat = convex(color=(1,0,0.5)) 

pomocą funkcji convex. 

x = arange(0,2*math.pi,2*math.pi/3) 

trojkat.pos = transpose( (sin(x)+POZ_x, cos(x)+POZ_y, 0*x+POZ_z) ) 

25

• tworzenie obiektów z pojedynczych trójkątów – triangularyzacja obiektów 

Często zdarza się, że geometria bryły jest skomplikowana a przybliżanie jej budowy 

za pomocą dostępnych brył prymitywnych może okazać się zbyt pracochłonne lub 

niewystarczające. Kolejna funkcja jaka zostanie zaprezentowana umożliwia budowę obiektu 

z pojedynczych trójkątów [G]. Ogromna większość programów do grafiki 3D korzysta 

z modeli (brył), które składają się z trójkątów. Przedstawienie geometrii obiektu złożonego 

za pomocą trójkątów (lub w przestrzeni 3D za pomocą czworościanów) nazywane jest 

triangularyzacją. Gdy będziemy mieli listę punktów takiego ztriangularyzowanego obiektu 

oraz dla każdego z wierzchołków określony atrybut koloru i powierzchni normalnej (ang. 

normal) możemy użyć funkcji faces() do stworzenia powierzchni pomiędzy odpowiednimi 

trójkami punktów. Metoda oparta o tą zasadę jest stosowana z powodzeniem w wielu 

językach programowania. 

Rysunek 17: Przy konstruowaniu obiektów z trójkątów musimy pamiętać 

o zdefiniowaniu obydwu stron obiektów. Widoczny na ilustracji kwadrat 

czerwono-żółty ma zdefiniowaną tylko jedną stronę więc jest widoczny 

wyłącznie z jednej strony 

Obiekty tworzone przy pomocy funkcji faces() są tak naprawdę tablicami punktów 

(podobnie jak obiekty typu curve, convex, etc), tak więc aby uzyskać łatwy dostęp do całego 

obiektu niezbędne może się okazać scalenie przy pomocy funkcji frame(). Nadanie 

poszczególnych atrybutów dla poszczególnych punktów może wyglądać następująco: 

KLC=(1,1,0)#kolor zolty 

KLB=(1,0,0)#kolor czerwony 

#KWADRAT - widoczny tylko z przodu 

#triangle 1 

Tmap2 = faces() 

Tmap2.append(pos=(0,0,0), normal = (0,0,1), color = KLB) 

Tmap2.append(pos=(1,0,0), normal = (0,0,1), color = KLB) 

Tmap2.append(pos=(0,1,0), normal = (0,0,1), color = KLC) 

#triangle 2 

Tmap = faces() 

Tmap.append(pos=( 1,1,0), normal = (0,0,1), color = KLC) 

Tmap.append(pos=( 0,1,0), normal = (0,0,1), color = KLC) 

Tmap.append(pos=( 1,0,0), normal = (0,0,1), color = KLB) 

Każda ścianka trójkąta jest widoczna tylko z jednej strony. To, która strona jest widoczna 

zdeterminowane jest przez kolejność podawania punktów. Kiedy spojrzymy na ściankę, 

będzie ona widoczna tylko wówczas jeżeli kolejność podawania punktów do funkcji face() 

będzie zgodna z ruchem wskazówek zegara. Jeżeli zatem będziemy potrzebowali trójkąt 

widoczny z obu stron, musimy stworzyć kolejny trójkąt podając punkty w kierunku 

przeciwnym do ruchu wskazówek zegara. 

26

Jeżeli nie określimy atrybutu dla 

powierzchni normalnej, trójkąt taki będzie 

oświetlony tylko przez światło otaczające. 

Aby główne światło oddziaływało na 

powierzchnię trójkąta musimy określić 

atrybut powierzchni normalnej 

(oświetlenie) dla każdego z wierzchołków. 

W najprostszym przypadku kierunek 

światła głównego jest prostopadły do 

powierzchni trójkąta a przylegające na 

około trójkąty mają widoczne krawędzie 

(ang. solid). 

Gładkie krawędzie mogą być wytworzone 

przez uśrednienie atrybutów powierzchni 

normalnej dla dwóch przylegających 

ścianek w punkcie zetknięcia każdego z 

Rysunek 18: Obiekty wykonane z trójkątów przy pomocy 

funkcji faces. a) powierzchnia obiektu wygładzona 

(ang. smooth) b) powierzchnia obiektu bez wygładzenia 

(ang. solid) 

wierzchołków. Jasność powierzchni jest proporcjonalna do cos (gdzie - to kąt 

pomiędzy wektorami normalnymi) i natężenia światła głównego. 

Jeżeli określimy różne kolory dla poszczególnych wierzchołków w danym trójkącie, nie to 

otrzymamy jednobarwnego trójkąta gdyż VPython interpoluje kolory w poprzek 

powierzchni trójkąta. Podobnie jest również dla atrybutów powierzchni normalnej, jeżeli 

będą różnice w tych atrybutach to powierzchnia nie będzie jednolicie jasna. 

Funkcja face() jest zatem przeznaczona do konstruowania nowych brył. Jej elastyczność jest 

wystarczająca dla implementacji algorytmów wygładzania powierzchni, kolorowania 

wierzchołków, wykonywania powierzchni jedno lub obustronnie oświetlonych etc, ale 

należy pamiętać, że wszystkie kalkulacje muszą być wykonane przez programistę. 

W przypadku brył standardowych takich jak stożki i sfery algorytmy wygładzania 

powierzchni są wewnętrznie zaimplementowane w strukturze wywołującej daną bryłę. 

Relacjonowanie z kilku kamer jednocześnie 

Wywołując dowolną bryłę z biblioteki Visual inicjujemy automatycznie okno 3D, które nazwane 

jest scene. W przypadku gdy samodzielnie zdefiniujemy parametry okna nie zostanie ono 

stworzone dopóki nie zainicjujemy jakichś obiektów, które będą się tam znajdować, poza tym jeżeli 

już wcześniej w programie zainicjujemy własne okno 3D nie musimy interesować się oknem o 

nazwie scene. 

Polecenie display() tworzy w pamięci okno 3D wraz ze specyficznymi dla niego atrybutami. 

Powoduje także automatyczną selekcję tego okna, i zwraca je w wyżej wymienionym przypadku. 

Dla przykładu, poniższy skrypt wywołuje okno 3D o rozdzielczości 600 na 200 pikseli z tytułem 

„Moje okno” umieszczonym na belce stanu. Środek okna (centrum) znajduje się w punkcie (3,0,0) a 

kolor wypełnienia okna jest biały. 

scene2 = display(title='Moje okno', 

width=600, height=200, 

27

center=(3,0,0), background=(1,1,1)) 

Ogólne opcje okna 3D (display window): 

select() - aktywuje specyficzne okno (wyselekcjonowane), zatem obiekty będą rysowane 

wewnątrz tego okna na przykład scene.celect() 

foreground – ustawia kolor który będzie używany podczas tworzenia obiektów na przykład takich 

jak sphere czy box, domyślną wartością tego parametru jest (1,1,1) – kolor biały, 

na przykład scene.foreground = (1,1,0) 

background - ustawia kolor który posłuży do wypełnienia okna (tzw. kolor tła);domyślnym 

kolorem jest czarny 

stereo – opcja obrazu dwukolorowego stosowanego przy wizualizacji trójwymiarowej. 

scene.stereo = 'redblue' generuje czerwoną scenę dla oka lewego oraz niebieską scenę dla 

oka prawego. Obraz taki należy oglądać 

przez czerwono-niebieskie okulary 

przystosowane do tego celu. Oprócz 

czerwono-niebieskiego odcienia możemy 

uzyskać obraz w kolorach „red-cyan” oraz 

„yellowblue”. Jeżeli obiekty znajdujące się 

w scenie nie będą w kolorze białym mogą 

w pewnym stopniu zmienić barwę na 

ciemniejszą i nie będą zbyt dobrze 

widoczne. Opcja scene.stereo = 'active' 

pozwala renderować obraz na przemian dla 

lewego oraz prawego oka, przy czym 

oglądanie takiego obrazu wymaga 

specjalnych okularów (a w zasadzie hełmu 

wyposażonego w dwa ciekłokrystaliczne 

wyświetlacze) pracujących w systemie 

quad buffered stereo. Opcja 

scene.stereo = 'passive' renderuje obraz 

podwójnie. Obraz taki może być 

Rysunek 19: Widok sceny przy włączonej opcji 

stereo. 

wyświetlany przez dwa zsynchronizowane ze sobą projektory, lub przy pomocy 

przeglądarki do stereogramów. Jeżeli karta graficzna nie posiada wspomagania wyżej 

wymienionych opcji ustawienia parametrów nie przyniosą żadnego efektu. 

Opcja quad buffered 'active' stereo jest tylko dostępna na specjalistycznych kartach 

graficznych posiadających niezbędne wspomaganie sprzętowe oraz okulary (hełm) 

wyposażony w zmienną migawkę dla każdego oka z osobna (shutter glass connector) na 

przykład system ten posiadają komputery SGI oraz komputery klasy PC wyposażone w 

kartę nVidia Quadro a także 3DLabs Wildcat graphics cards. Renderując każdy obraz 

podwójnie z różnego punktu obserwacji uzyskujemy sztucznie wygenerowaną iluzję głębi 

przestrzeni. Specjalne okulary (shutter glasses) zsynchronizowane z na przemian 

pojawiającymi się obrazami dla każdego oka sprawiają, że każde oko widzi właściwy 

obraz dla niego a nasz mózg wykonuje całą resztę. Metoda ta jest nazywana 'quad 

buffered' - „czterokrotnego powtarzania obrazu” ponieważ biblioteka OpenGL buforuje 

obraz dla każdego oka z osobna a obraz taki jest wyświetlany z podwójną częstością 

w celu uzyskania płynnych przejść ruchu. Opcja 'passive' wymaga kart graficznych 

mogących wyświetlać obraz na dwóch monitorach lub projektorach. 

28

Rysunek 20: Scena renderowana z użyciem opcji passive. Przyglądając się nieco dokładniej niniejszej ilustracji 

zauważymy, iż obraz jest renderowany z dwóch różnych ustawień kamery (analogicznie do pary oczu). 

ambient – ilość światła niekierunkowego (otaczającego).Wartością domyślną jest 0.2. 

lights – lista wektorów reprezentujących kierunek światła głównego. Jego parametrem 

charakteryzującym jest natężenie. I tak na przykład scene.lights = [vector(1,0,0)] wraz z 

parametrem scene.ambient = 0 sprawi, że światło będzie padało tylko z prawej strony 

ponieważ wartość światła padającego z innych kierunków niż główny wynosi 0, zatem 

parametr scene.ambient odnosi się do światła otaczającego. Domyślnie ustawiane są dwa 

światła, pierwsze w punkcie (0.17, 0.35, 0.70), którego jasność (magnitude) wynosi 0.8, 

oraz drugie (-0.26, -0.07, -0.13), magnitude 0.3. Atrybuty światła głównego i światła 

otacającego muszą by odpowiednio dobrane, ponieważ całkowita intensywność światła w 

dowolnym miejscu sceny musi wynosić 1.W przeciwnym wypadku otrzymamy scenę 

niedoświetloną lub oświetloną światłem o zbyt dużym natężeniu. 

cursor.visible – ustawienie tego parametru pozwala na wyłączenie widoczności kursora myszy 

scene.cursor.visible = 0. Ta opcja jest często stosowana podczas przesuwania i obracania 

obiektów lub w przypadku gdy kursor myszy w danej scenie po prostu staje się 

zbyteczny. Przywrócenie widoczności kursora następuje po wydaniu polecenia 

scene.cursor.visible = 1. 

objects – lista obiektów w danym oknie 3D posiadających atrybut visible. Obiekty nie posiadające 

możliwości wizualizacji nie wchodzą w skład tej listy. Lista taka pozwala kontrolować 

atrybuty danej grupy obiektów. Poniższy fragment skryptu pozwala na zmianę parametru 

koloru wszystkich kul znajdujących się w danej scenie. 

for obj in sceneB.objects: 

if obj.__class__ == sphere # możemy pisać sphere lub 'sphere' 

obj.color = (1.0,1.0,0.0) 

29

Parametry pozwalające kontrolować okno 

x, y - pozycja okna na ekranie. Punktem (0,0) jest lewy górny róg ekranu. 

width, height - szerokość i wysokość wyświetlanego okna na przykład scene.height =800, 

scene.height =600 

title – tekst wyświetlany na belce stanu okna np. scene.title = 'Trajektoria ruchu ' 

visible – należy zawsze się upewnić że scena jest widoczna wydając polecenie sceneB.visible=1, 

które powoduje wizualizacje sceny, ustawienie tego parametru na zero spowoduje, że 

okno nie będzie wyświetlane. 

fullscreen – powoduje otworzenie okna w trybie pełnoekranowym bez ramki i belki tytułowej. 

Zamknięcie okna uruchomionego w tym trybie możemy uzyskać ponaciśnięciu klawisza 

Escape. 

exit – domyślną wartością tego parametru jest scene.exit = 1 powoduje on zamknięcie wszystkich 

okien (zarówno 3D jak i wykresów) i wyjście z programu po naciśnięciu ikony wyjścia. 

Jeżeli wartość tego parametru dla każdego wyświetlanego okna będzie wynosić 0, to 

podczas opuszczania programu będziemy musieli zamykać każde okno z osobna. 

Kontrola widoku 

center – punkt, na który jest nieustannie jest skierowana kamera, nawet wówczas gdy użytkownik 

obróci kamerę. W przypadku zmiany wartości tego punktu kamera zachowuje ten sam 

kierunek spojrzenia na centrum sceny dopóki nie zostanie zmieniony parametr foward. 

Wartość domyślna parametru center to środek układu współrzędnych (0.0,0.0,0.0). 

foward – parametr ten pozwala kontrolować ustawienie kamery w przestrzeni. Foward jest 

wektorem pomiędzy punktem położenia kamery oraz punktem na który jest skierowana 

kamera (punkt center). Użytkownik 

zmieniając zakres lub kąt patrzenia 

zmienia wartość tego parametru. 

Wartością domyślną jest (0,0,-1) 

range – zakres widoczności jaki ma być 

objęty kamerą. Obszar ten 

wyznaczany jest względem punktu 

center. Wartością domyślną jest 

(10,10,10). Automatyczną kontrolę 

zakresu możemy uzyskać włączając 

parametr autoscale. 

Niekiedy zachodzi potrzeba oglądania 

animacji bądź symulacji jednocześnie z kilku 

położeń kamery [F]. Możemy to osiągnąć 

inicjując kilka scen jednocześnie i kopiując 

wszystkie elementy z jednej sceny do innych. 

Uzyskamy w ten sposób możliwość 

indywidualnej kontroli parametrów dla 

każdej z kamer oddzielnie. 

Rysunek 21: Relacjonowanie przebiegu animacji z czterech 

niezależnych położeń kamery. 

30

Wykresy – znakowanie danych 

Przy rysowaniu wykresu na przykład typu (gdots) można określić inny kolor danych, które 

spełniają określony warunek czyli poddać dane filtrowaniu. Dla przykładu przedstawiono dane, 

które zostały poddane filtrowaniu ze względu na amplitudę (przebiegi A,B,C do których 

zastosowano filtr ograniczający), dane modyfikowane przez filtr progowy (przebieg D), oraz dane 

przekształcane przez filtry kierunkowe (przebiegi E,F). 

Przyjmując zatem, że dane oznaczone kolorem zielonym są przepuszczane przez filtr (spełniają 

określony warunek) a dane oznaczone kolorem czerwonym są ograniczane, przez filtr (nie spełniają 

określonego warunku) otrzymamy filtr typu ograniczającego (przebiegi A,B,C). 

Rysunek 22: Podczas rysowania wykresu istnieje możliwość wyróżnienia innym kolorem określonej grupy danych. 

31

5. Ruch bryły sztywnej 

Wyznaczanie drogi hamowania samochodu 

Droga zatrzymania pojazdu [3] podczas gwałtownego hamowania składa się z drogi reakcji 

kierowcy oraz drogi hamowania 2 b d . Pierwsza z nich wynika z pewnego stałego czasu 

upływającego pomiędzy dostrzeżeniem przeszkody a naciśnięciem hamulca i nosi nazwę czasu 

reakcji. Druga natomiast (przy założeniu stałej siły hamowania) jest wprost proporcjonalna do 

kwadratu prędkości i zależy między innymi od od rodzaju nawierzchni (asfalt, kostka kamienna 

itp.), od stanu nawierzchni (sucha, mokra, pokryta lodem, posypana piaskiem itp.) i kąta nachylenia 

jezdni do poziomu. 

v 2 

b d = 

2g k 

cossin 

Oczywiście siły tarcia zawsze opierają się ruchowi i najczęściej są zależne od wzajemnego 

oddziaływania stykających się powierzchni. Wynika z tego, że tarcie jest jedną z sił kontaktowych 

i zwykle jest ono styczne do oddziałujących ze sobą powierzchni a wartość siły tarcia jest funkcją 

siły normalnej do powierzchni trących oraz chropowatości powierzchni 3 . 

F T = k N gdzie N siła oddziaływania bloku z podłożem (prostopadłą) do powierzchni trących 

Rysunek 23: Siły działające na ciało, które powodują zmianę 

prędkości ciała. 

W kolejnej symulacji wyżej wymieniona siła będzie odgrywać kluczową rolę, gdyż to 

właśnie ona znacząco wpływa na ruch ciała powodując większe wytracanie prędkości a tym samym 

czyni zjawisko bardziej realistycznym. 

Gdy bryła sztywna porusza się w górę równi pochyłej przyspieszenie ma stałą wartość i wynosi 

a= g cossin 

a prędkość maleje liniowo zczasem. 

Przejdźmy zatem do serca programu. Algorytm całkowania równań ruchu zbudowany został 

w oparciu o klasyczną metodę Eulera i wykonywany jest według poniższego schematu. 

v tdt =v x 

tdt at 

xtdt=x tdt v tdt 

Nie uwzględnia on wyliczania w każdym kroku czasowym przyspieszenia gdyż przyjmuje ono stałą 

wartość. 

Aby sprawdzić jak kształtuje się długość drogi hamowania w zależności od kąta nachylenia drogi 

2 b d skrót od ang. braking distance - droga hamowania 

3 Chropowatość powierzchni jest mierzona zazwyczaj w mikrometrach 

32

do poziomu wystarczy sporządzić jej wykres (patrz plik sd_wyniki_wykres.py). 

Rysunek 24: Zależność drogi hamowania od kąta nachylenia jezdni do poziomu. Przecięcie zielonych linii 

obrazuje rozwiązanie dla wprowadzonych przez użytkownika parametrów początkowych (patrz rys. 

poniżej) 

Rysunek 25: Wyznaczenie drogi hamowania dla bryły sztywnej. 

33

Ruch postępowo obrotowy na równi 

Jeżeli na równi pochyłej ustawimy walec [3],[8],[9] i puścimy swobodnie, zacznie się obracać i 

zjeżdżać. Będzie się tak działo tylko wtedy gdy współczynnik tarcia będzie miał odpowiednią 

wartość. Jeżeli nie byłoby tarcia lub byłoby ono zbyt małe, walec nie staczał by się, lecz zsuwał po 

równi a jego prędkość kątowa u podnóża równi mogłaby być nawet równa zeru. Przyjmijmy 

lokalny układ współrzędnych w którym oś x-ów jest równoległa po płaszczyzny równi a oś y-ów 

jest do niej prostopadła. Wówczas równania ruchu dla walca znajdującego się na równi pochyłej 

przyjmują następującą postać. 

∑ F y local 

=mg cos−mg cos=m a y 

∑ F xlocal 

=mg sin −T =m a x 

gdzie T - wartość siły tarcia a x - 

przyspieszenie liniowe środka ciężkości 

walca 

Gdy siła sprężystości równoważy siłę 

nacisku m a y 

=0 . Zakładamy także , 

że walec stacza się bez poślizgu. 

Ruch obrotowy dookoła środka masy 

opisany jest równaniem 

= I śr.m. 

Obrotu walca nie powoduje jednak ani 

siła sprężystości F s ani F c , gdyż 

obie przechodzą przez środek masy i 

ich moment wypadkowy jest równy 

zeru. Moment siły różny od zera daje 

tylko siła tarcia T , której ramię jest równe promieniowi walca. Możemy więc zatem napisać: 

F R=I śr.m. 

moment bezwładności walca jest równy I śr.m. 

= 1 2 m R2 , 

Rysunek 26: Rozkład sił działających na walec staczający się po 

równi pochyłej. 

a przyspieszenie kątowe = a R 

 

więc F =I śr.m. 

R = m a 

2 

Przyspieszenie walca na równi obliczymy podstawiając powyższe równanie do drugiego równania 

ruchu (dla osi x-ów). W rezultacie otrzymamy a= 2 3 g sin . 

Prędkość środka masy przy założeniu zerowej prędkości początkowej jest określona równaniem 

v= 4 3 g h gdzie h jest wysokością równi. 34

Rysunek 27: Symulacja ruchu walca na równi pochyłej. 

Poślizg kuli przy pchnięciu techniką bilardową. 

Kolejna symulacja ilustruje przykład z życia codziennego. Przy pchnięciu kuli dokładnie w środek 

masy wektor popędu jest dokładnie poziomy i przechodzi przez środek kuli. Tuż po uderzeniu kula 

bilardowa posiada liniową prędkość 

początkową, lecz po krótkim czasie 

zaczyna się obracać a chwilę później 

kontynuuje ruch bez poślizgu (toczy się). 

Niniejsza symulacja pozwoli wyznaczyć 

odległość na jaką przemieści się kula 

zanim przestanie się ślizgać [7],[8]. Tak jak 

w poprzednich przypadkach zostały 

poczynione założenia upraszczające. 

Przyjmujemy, że kula nie odkształca się 

podczas trwania uderzenia a popęd siły ma Rysunek 28: Pchnięcie kuli techniką bilardową. 

stałą wartość. Uderzenie kończy się 

nadaniem kuli liniowej prędkości początkowej v 0 , również stałą wartość ma współczynnik tarcia 

kinetycznego między kulą a podłożem. Przyspieszenie środka masy kuli jest stałe,ponieważ 

35

wszystkie działające siły są stałe. Dlatego też dla ruchu postępowego możemy napisać: 

F =m a=m v – v i f 

t przy czym v i 

=v 0 i v f = f R 

a v i , v f oznaczają odpowiednio liniową prędkość początkową i końcową 

Siła wypadkowa F = k m g 

 

tak, że k 

mg=m v – v i f 

t 

Przyspieszenie kątowe dookoła osi przechodzącej przez środek masy jest stałe, tak że dla ruchu 

obrotowego możemy napisać: 

= I =I f – i 

t 

k 

m g R= 2 5 m R2 v f 

Rt 

jeżeli i=0 to = I v f 

Rt 

liniowa prędkość końcowa będzie dana zależnością v f 

= 5 7 v i 

czas trwania poślizgu t= v −v i f 

g = 2 v i 

7 k 

g 

odległość na jaką przemieści się kula bilardowa zanim przestanie się ślizgać jest określona 

równaniem x= 12 

2 

v i 

49 k 

g . 

W analogiczny sposób została skonstruowana symulacja ilustrująca wyznaczenie drogi poślizgu 

krążka mającego początkową prędkość kątową, który puszczamy swobodnie na poziomą 

powierzchnię. (patrz plik z_piskiem_opon_04.py). 

Rysunek 29: Symulacja ilustrująca wyznaczanie drogi poślizgu przy pchnięciu 

kuli techniką bilardową. 

Przytoczone przykłady ilustrują istotny aspekt zagadnień kinetyki ciała sztywnego a mianowicie 

rozważając ruch obrotowy bryły sztywnej, trzeba pamiętać nie tylko o o kierunku i wielkości 

działającej siły, lecz także o punkcie jej przyłożenia. 

36


Obiekt zmieniający geometrię w czasie. 

Dotychczas symulowane były różne aspekty ruchu punktów materialnych i brył sztywnych, teraz 

zaś głównym celem jest pokazanie jak postępować ze zbiorem punktów materialnych i sprężyn. 

Systemy złożone z dużej ilości punktów materialnych mogą służyć między innymi symulacji 

tkanin[3], ciał stałych sprężystych [F], przydatne także się stają przy modelowaniu włosów, trawy, 

ciał sypkich na przykład piasku [E], a nawet dymu czy ognia[5]. 

Zastępowanie ciał sztywnych przez zbiory punktów materialnych ułatwia zadanie, gdyż nie musimy 

zajmować się ruchem obrotowym i jego równaniami co jest niezbędne przy ruchu brył sztywnych. 

Krok taki ułatwia nie tylko obliczanie sił i całkowanie równań ruchu, lecz również zdecydowanie 

upraszcza obliczenia dotyczące zderzeń, ponieważ mamy jedynie do czynienia z popędem w ruchu 

postępowym. 

Niewątpliwie ogromnym źródłem informacji dla osoby rozpoczynającej przygodę z symulowaniem 

zjawisk fizycznych może stanowić zestaw standardowych skryptów jakie są dostępne w katalogu 

C:\Program Files\Python23\Lib\site-packages\visual\demos\ 4 

Dlatego kolejna symulacja stanowi tylko modyfikację standardowego skryptu o nazwie drape.py 

Przedmiotem symulacji będzie uproszczony model sznura opadającego na przeszkodę, którą będzie 

kilka kul. Linę zbudowana będzie z punktów materialnych każdy o masie m połączonych przy 

pomocy elementu sprężynująco-tłumiącego. Dla zwiększenia szybkości obliczeń pominięta została 

wizualizacja dla mas punktowych, zaś elementy łączące te punkty przedstawione będą przy pomocy 

prostoliniowych odcinków. Przejdźmy zatem do omówienia głównej struktury programu. Na 

początek definiujemy stałe takie jak masa punktu materialnego, przyspieszenie grawitacyjne, krok 

czasowy symulacji, współczynnik sprężystości oraz tłumienia. 

restlength = 0.1 #dlugosc pojedynczego elementu 

m = 0.005 * restlength #masa pojedynczego elementu 

g = 9.81 #[m/s^2] 

dt = 0.003 #krok czasowy symulacji 

k = 3.5 #wspolczynnik sprezystosci 

damp = 0.992#wspolczynnik tlumienia 

Kolejno wykonujemy obiekt przedstawiający linę, który w tym przypadku jest krzywą. Oraz 

nadajemy każdemu punktowi tej krzywej atrybut fizyczny - pęd początkowy równy zeru. 

band = curve( x = arange(-1,1,restlength), y = 1,z = 0, color=color.black,radius 

= 0.01) 

band.p = band.pos * 0 #nadanie pedow poczatkowych 

Jak wspomniane było wcześniej, przeszkodę na którą opadać będzie sznur, stanowić będzie kilka 

sfer, które teraz wykonamy. Oczywiście położenie każdej ze sfer jest dowolne, niemniej pamiętać 

należy by wszystkie kule umieszczone zostały w jednej liście [4], by później możliwy był łatwy 

dostęp do atrybutu położenia każdej z nich. 

#inicjowanie przeszkody dla sznura 

spheres = [] 

4 Katalog Program Files jest opcjonalny i przy niektórych wersjach Pythona nie zaleca się używania tego katalogu 

przy instalacji języka. 

37

for i in range(nspheres): 

for j in range(nspheres): 

s = sphere( pos = (i*0.4+0.1*j,0.1 + i*0.1-0.3*j,-0.01+0.2*j), 

radius = 0.25, 

color = color.yellow ) 

spheres.append( s ) 

W takiej właśnie symulacji zachowania się zbioru punktów materialnych sprężyny i tłumiki drgań 

odgrywają ważną rolę. Siły sprężystości łączą poszczególne punkty materialne ze sobą i utrzymują 

je w pewnej odległości. Tłumiki zapewniają łagodność ruchów eliminując gwałtowne drgania 

i wstrząsy. Tłumiki są też bardzo istotne z punktu widzenia stabilności numerycznej symulacji. 

Zobaczmy jak skonstruowana jest pętla odpowiedzialna za ruch obiektu. 

W każdym kroku czasowym pęd każdego z punktów materialnych zostaje zmniejszony o pewną 

wartość czyli nasz sznur porusza się w ośrodku tłumiącym jego ruch. Jak widać istnieje korelacja 

pomiędzy krokiem czasowym symulacji i oporem. Niemniej jednak w taki sposób będzie działał 

tłumik drgań. 

band.p = band.p * damp #tlumienie ruchu 

#w kazdym kroku czasowym 

Aby nieco uatrakcyjnić symulację załóżmy że jeden 

z końców liny jest przywiązany czyli pierwszy 

punk materialny będzie mieć zawsze pęd równy 

zeru. 

band.p[0] = 0# zaczepienie w punkcie 

startu punktu o numerze 0 (wyzerowanie 

pedu) 

Oczywiście w ten sam sposób możemy 

„przywiązać” dowolny punkt liny i tak na przykład 

chcąc unieruchomić ostatni element liny napiszemy 

band.p[-1] = 0 

Rysunek 30: Numerowanie elementów listy i tak 

element listy o numerze1 lub -4 odnosi się do punktu 

materialnego numer 2. 

Gdy zaś pominiemy tę opcję całkowicie spowodujemy że cała lina będzie opadać na przeszkodę. 

Jak zawsze w każdym kroku czasowym musi zostać zaktualizowana pozycja każdego z punktów 

p th 

materialnych. Stosując klasyczną metodę Eulera możemy napisać xth=xt h 

m 

gdzie h jest krokiem czasowym symulacji (dyskretnym przyrostem czasu) 

Na każdy z punktów działa siła grawitacji więc pęd każdego z punktów w każdym kolejnym kroku 

czasowym można zapisać jako m v th =mv tm hat 

band.pos = band.pos + band.p/m*dt #wyznaczenie nowego polozenia 

band.p[:,1] = band.p[:,1] - m * g * dt # p=p-m*g*t wyznaczenie nowych pędów 

kolejno przystępujemy do wyznaczenia wzajemnych odległości pomiędzy punktami najpierw 

w formie wektorów (każdego punktu z każdym) a następnie zamianie odległości wektorowych na 

skalary. Krok taki był wykonywany przy wyznaczaniu położeń między planetami więc w tym 

przypadku omówienie zostanie pominięte. Należy tylko pamiętać iż operacje takie są wykonywane 

na tablicach, które nie transformują się jak macierze. 

length = (band.pos[1:] - band.pos[:-1])#odleglosci pomiedzy punktami 

dist = sqrt(sum(length*length,-1))#wartosci odleglosci w formie listy 

38

W połączeniu między punktami działa siła zgodna z prawem Hook'a F =kx więc siły (skalarnie) 

działające pomiędzy każdymi dwoma punktami materialnymi wyznaczymy w następujący sposób: 

force = k * ( dist - restlength ) #F=k*x (skalarne) 

by zaś dostać siły w formie wektorów [2] musimy wartość poprzednio obliczonych sił pomnożyć 

przez wektory jednostkowe: 

force = length/dist[:,NewAxis] * force[:,NewAxis] 

Ostatnim krokiem pętli ruchu jest aktualizacja pędów. Z doświadczenia wiemy, że pomiędzy 

dowolną parą sąsiednich punktów materialnych w takiej linie działają siły naprężenia równe co do 

wartości lecz o przeciwnych zwrotach i punktach przyłożenia. Wyznaczyliśmy poprzednio n−1 

sił w formie wektorów, lecz punktów materialnych mamy n . Musimy zatem w oparciu o te 

wiadomości zaktualizować pędy wszystkich punktów materialnych. I tak od pierwszego punktu 

materialnego (mającego indeks z numerem zero - na liście - patrz rysunek wcześniejszy) do 

przedostatniego (włącznie) zapiszemy 

p th=p t F th 

band.p[:-1] = band.p[:-1] + 

force*dt 

i analogicznie od drugiego punktu Rysunek 31: Pary sił działające na poszczególne elementy liny. 

materialnego (mającego indeks 

z numerem 1 - na liście rys wcześniejszy) do ostatniego (włącznie) zapiszemy 

p th=p t − F th 

band.p[1:] = band.p[1:] - force*dt 

Pozostaje jeszcze kolizja z podłożem i przeszkodą. Zacznijmy od podłoża. 

Kontrola detekcji z podłożem jest bardzo prosta i sprowadza się do sprawdzania czy y-grekowa 

składowa któregokolwiek punktu materialnego nie jest mniejsza niż jest to określone przez poziom 

zerowy (czyli podłoże na które upadnie sznur). W przypadku gdy owa współrzędna jest mniejsza 

niż ten poziom, następuje zmiana jej wartości do poziomu zerowego oraz przypisanie tej składowej 

pędu równego zeru. 

if floor: 

#UDERZENIE O PODLOZE 

below = less(band.pos[:,1],poziom_zero)#below-ponizej 

band.p[:,1] = where( below, 0, band.p[:,1] ) 

#dla kazdego punktu znajdujacgo sie ponizej poziom_zero ustaw p=0 

band.pos[:,1] = where( below, poziom_zero, band.pos[:,1] ) 

#dla kazdego punktu znajdujacgo sie ponizej poziom_zero ustaw y=0 

Detekcja kolizji sznura ze sferą sprowadza się do sprawdzania czy którakolwiek ze składowych 

poszczególnych punktów materialnych nie znalazła się w odległości mniejszej niż promień sfery. 

W przypadku przekroczenia tej odległości korygowane jest położenie tego punktu materialnego do 

powierzchni sfery. Sama procedura wyznaczania miejsc dopuszczalnych i zakazanych dla ruchu 

sznura dotyczy wszystkich sfer jednocześnie i opiera się o bardzo wydajną metodę nakładania 

masek. Nieco bliżej problem ten zostanie omówiony przy symulacji gazu doskonałego. Zderzenie 

sznura z kulą jest niesprężyste i dlatego nie dochodzi do odbicia kolidujących punktów 

materialnych od sfery. Odbicie takie jest realizowane przez rozłożenie wektora pędu na dwa 

39

składowe wektory. Jeden prostopadły (normalny) do powierzchni sfery w punkcie kolizji oraz drugi 

styczny do tej powierzchni. Aby uzyskać zderzenie niesprężyste należy po prostu wyeliminować 

wektor normalny drugi natomiast podstawić jako wektor pędu tegoż punktu. I tak w najprostszym 

przypadku gdy którykolwiek z punktów uderzy z prędkością skierowaną dokładnie w środek sfery 

jego pęd zostanie całkowicie wygaszony. 

Rysunek 32: Symulacja kolizji ciała giętkiego z przeszkodą. 

Autorzy skryptu zadbali także o wizualizację naprężeń w sznurze powstających w wyniku kolizji 

z obiektem jak również powstających na skutek naciągnięcia liny spowodowanego działaniem jej 

własnego ciężaru. 

Wykresy – tworzenie histogramu 

Powinno by oczywiste, że poważna analiza statystyczna eksperymentu wymaga wykonania wielu 

zliczeń, pomiarów, etc. Oznaczać to będzie, że musimy zaprezentować dużą liczbę danych na 

jednym wykresie - histogramie. Jako przykład rozważmy grupę studentów zdających egzamin [12]. 

Maksymalna liczba punktów jaką można zdobyć wynosi 50. Studenci otrzymują następujące 

wyniki: 

26, 33, 38, 41, 49, 28, 36, 38, 47, 41 

32, 37, 48, 44, 27, 32, 34, 44, 37, 30 

(Oceny te przepisano z ułożonej alfabetycznie listy studentów). 

Poniżej został przedstawiony histogram ocen, w którym przyjęto jako granice przedziałów 

następujące liczby: 25, 30, 35, 45, 50. Pionowa skala jest tak dobrana, że pole powierzchni każdego 

prostokąta wyraża ułamek liczby studentów zaliczających się do danego przedziału. 

40

Rysunek 33: Histogram ocen uzyskanych przez studentów. 

Symulacja rzutu monetą 

W wyniku przeprowadzania eksperymentu rzutu monetą oczekuje się, że połowa z nich będzie 

reszką, mimo tego iż możliwe jest uzyskanie dowolnej liczby reszek (całkowita liczba wyrzuconych 

reszek zawiera się od zera do liczby rzutów). Działanie skryptu rzut_moneta.py [1] polega na 

uruchamianiu eksperymentów, które symulują liczbę rzutów dla danego eksperymentu. W wyniku 

takiego doświadczenia otrzymujemy za każdym razem pewną liczbę reszek z zakresu 

0iliczba rzutów . Wyniki następnie są zliczane i kumulowane w liście reszki[]. Zwięzłość 

programu uzyskana została przez zastosowanie metody indeksowania za pomocą wyliczanej 

wartości (liczba reszek staje się numerem indeksu listy zawierającej krotności występowania 

reszki). Ponadto program może drukować histogram w postaci tekstowej lub graficznej – z użyciem 

biblioteki VPython. Histogram ten za każdym razem powinien przypominać kształt krzywej Gaussa 

i rozciągać się wokół połowy liczby rzutów. 

Rysunek 34: Przykład działania skryptu rzut_monetą. 

41

eszki (liczebność wyniku): 

[0, 0, 2, 5, 18, 35, 58, 90, 96, 82, 56, 40, 12, 4, 0, 2, 0] 

histogram tekstowy: 

0 

1 

2 * 

3 * 

4 * * 

5 * * * * 

6 * * * * * * 

7 * * * * * * * * * 

8 * * * * * * * * * * 

9 * * * * * * * * * 

10 * * * * * * 

11 * * * * 

12 * * 

13 * 

14 

15 * 

16 

n_k 

f 

0.00 0.0000 

1.00 0.0000 

2.00 0.0040 

3.00 0.0100 

4.00 0.0360 

5.00 0.0700 

6.00 0.1160 

7.00 0.1800 

8.00 0.1920 

9.00 0.1640 

10.00 0.1120 

11.00 0.0800 

12.00 0.0240 

13.00 0.0080 

14.00 0.0000 

15.00 0.0040 

16.00 0.0000 

gdzie n_k - krotność występowania, f – częstość z jaką występuje reszka dla danej liczby 

eksperymentów 

Podsumowując informacje na temat wykresów widzimy, że okno wykresu jest blisko spokrewnione 

z oknem 3D. Główną różnicą jest to, że wykres jest zasadniczo dwu-wymiarowy i posiada 

nieznormalizowaną skalę dla osi x i y. Istotnym ułatwieniem jest to, że kiedy tworzymy wykres 

(obojętnie, czy zastrzegamy jaki to ma być typ wykresu, czy też nie) a następnie wywołujemy 

zwykły obiekt z biblioteki Visual taki jak box czy sphere, będzie on poprawnie skojarzony z 

oknem 3D (display window), a nie jak by się mogło wydawać z oknem gdisplay. Dzieje się tak 

dlatego, że zainicjowane okno wykresu jest zapisywane a dostęp do niego uzyskujemy dopiero 

wówczas gdy dokonujemy kreślenia wykresu. 

42

7. Wiele ciał w przestrzeni 

Ruchy planet 

Ruch ciała wokół nieskończenie ciężkiej planety 

Kolejna grupa symulacji dotyczy ruchów ciał w polu grawitacyjnym [7]. Prześledźmy zatem 

główne etapy konstrukcji takiej symulacji. Na początek zakładamy, że jedna z planet jest 

nieskończenie ciężka to znaczy nie będziemy uwzględniać jej ruchu. Wpływ innych ciał także 

pomijamy. Przyjmując za punkt wyjścia prawo powszechnego ciążenia oraz zasady dynamiki 

Newtona spróbujemy wyznaczyć numerycznie trajektorię niewielkiego ciała, które będzie się 

poruszać z pewną prędkością początkową. 

Na podstawie podobieństwa trójkątów stwierdzamy, że składowa siły w kierunku poziomym ma się 

tak do całkowitej siły jak pozioma współrzędna x do przeciwprostokątnej czyli 

F x 

=−∣F∣ x r 

. 

Rysunek 35: Siły działające na ciało znajdujące się w polu grawitacyjnym 

planety. 

Korzystając z prawa powszechnego ciążenia możemy napisać, że składowa ta równa się iloczynowi 

masy planety 2 i szybkości zmiany jej prędkości w kierunku x 

m dv x 

dt =−GMm x r 3 

podobnie postępując uzyskamy zależności na składową siły w kierunku y oraz z. Promień 

r wyznaczymy następująco r= x 2 y 2 z 2 . 

Aby dodatkowo uprościć rachunki przyjmujemy, że GM =1 . 

Prześledzimy trajektorię planety przyjmując jako warunki początkowe: położenie planety w chwili 

startu p 2 

=0.5 i0.0 j0.0k , prędkość v 2 

=0.0 i1.63 j0.0 k , krok czasowy symulacji 

dt=0.1 . Dobranie takich parametrów zagwarantuje nam, że ruch będzie się odbywał w 

płaszczyźnie x y. Ostatecznie przyspieszenie w kierunku osi x wynosić będzie a x 

=− x r 3 

a w 

43

kierunku y a y 

=− y r 3 odległość zredukuje się do postaci r= x 2 y 2 

Stosując zmodyfikowaną metodę Eulera otrzymamy 

dt 

x tdt=x t dt vt 2 

dt 

vt 2 =v dt 

t− 

2 dt a t 

at =− x r 3 

v dt 

2 =vt 0 dt 

2 at 0 


Zatem schemat działania algorytmu będzie wyglądał następująco. W pierwszej kolejności 

wyznaczamy przyspieszenie działające na ciało w punkcie startu następnie, prędkość pośrednią to 

dt 

jest w chwili czasu równej 

2 

a=− x r 

v 3 

dt 

2 =vt 0 dt 

2 at 0 

W każdym następnym kroku czasowym dokonywane są obliczenia nowego położenia, 

przyspieszenia działającego na ciało oraz prędkości pośredniej. 

dt 

x new 

= xtdt vt 2 

a=− x new 

∣x new ∣ 3 

dt 

v 

t 

2 =v dt 

t− 

2 dt at 

Algorytm dla zmodyfikowanej metody Eulera wygląda następująco: 

def euler(obj): 

"""Funkcja wylicza a,v,x na podstawie param.pocz. 

Zmodyfikowana metoda Eulera""" 

if czas==0: 

#dla chwili poczatkowej 

obj.acc=-obj.frame.pos/mag(obj.frame.pos)**3 

obj.v_posrednia = obj.velocity + (dt/2)*obj.acc 

#podstawienie nowych wartosci polozenia i predkosci 

obj.v_posrednia = vector(obj.v_posrednia) 

else: 

#dla nastepnych krokow czasowych 

S_new = obj.frame.pos + obj.v_posrednia * dt 

obj.acc = -(S_new*(1/(mag(S_new)**3))) 

obj.v_posrednia = obj.v_posrednia + obj.acc * dt 

#podstawienie nowych wartosci polozenia i predkosci 

obj.frame.pos=vector(S_new) 

obj.velocity=vector(obj.v_posrednia) 

return 

44

Wyniki symulacji można porównać z danymi precyzyjnymi które wyznaczane są przy pomocy 

funkcji drukuj_dane_precyzyjne(). W przypadku gdy m 1 

≫m 2 masę zredukowaną 

przyjmujemy jako ≈m 2 . Moment pędu układu dwu punktów materialnych w ruchu względem 

układu środka masy określamy jako [6],[8],[9]: 

J S =r× ˙r 

zaś energia kinetyczna układu dwu punktów materialnych w ruchu względem układu środka masy: 

E S = v2 

2 − gdzie zgodnie z przyjętymi założeniami =G m 1 m 2 

r 

wyznaczane są następująco: 

a= − , 

2 E 

b= S 2 

−JS 

2 E S , 

c=a 2 – b 2 

r max 

=ac , 

r min 

=a−c , 

okres obiegu planety T period 

= 

2 ab 

J S . 

Korzystając ze wzorów na parametry elipsy otrzymujemy 1 4 

a następnie wzoru na energię 

E S =− 

2 a , 

uzyskamy zależność 

2 

T period 

= 22 a 2 

= 42 a 3 

E S 

a po uwzględnieniu założeń 

2 

=4 2 a 3 . 

T period 

J S 

T 2 2 period 

=− 2 a 2 J S 2 

2 E S 

. Parametry elipsy 

Proporcjonalność T 2 ~a 3 jest dla ruchów planet trzecim prawem Keplera. Widać wyraźnie, że to 

prawo nawet w mechanice nierelatywistycznej obowiązuje jedynie w przybliżeniu. Jednakże to 

przybliżenie jest bardzo dobre ze względu na to, że warunek m 1 

≫m 2 dla masy Słońca m 1 i 

masy planety m 2 spełniony jest bardzo wyraźnie. 

45

Rysunek 36: Symulacja ruchu niewielkiego ciała wokół planety. Czerwone kropki obrazują kolejne położenia planety. 

Uwaga: 

W przykładzie wykorzystano ruch po krzywej w płaszczyźnie x y, lecz przy tak zdefiniowanych 

algorytmach ruchu trajektoria może być krzywą zorientowaną dowolnie w trzech wymiarach 

niemniej jednak trajektoria takiego ciała jest krzywą płaską (2D). 

46

Prawo pól Keplera 

Ruch w czasie którego jest zachowany moment pędu: 

J =m r×v =const 

ma dodatkowo w mechanice nierelatywistycznej, ze względu na stałość masy, tę własność, że: 

J 

2m = 1 r×v =const 

2 

gdzie wektor r×v / 2 jest nazywany prędkością polową punktu materialnego[6],[8],[9]. Nazwa 

ta wywodzi się stąd, że wartość bezwzględna tego wektora pomnożona przez dt równa jest 

∣r× ds∣/2 gdyż ds=v dt , a zatem przedstawia pole trójkąta zakreślone przez r w ciągu 

t 

1 

czasu od t do tdt . Całka ∫ ∣r ×v∣dt daje więc pole zawarte pomiędzy wektorami 

2 

t 0 

r t 0 

, r t oraz łukiem toru w przedziale czasu 〈t 0 

, t〉 . Wywnioskować zatem można, że 

t 

J 

2m t – t = 1 ∫ 0 

∣r×v∣dt 

2 

t 0 

to znaczy pole rośnie liniowo z czasem, gdy J =const. , co stanowi jednocześnie treść drugiego 

prawa Keplera. Wizualizację pola powierzchni zakreślanego przez promień wodzący w czasie 

jednostkowego czasu (miesiąca) uzyskać możemy uruchamiając funkcję KEPLER(). 

Rysunek 37: Pole powierzchni zakreślane przez promień 

wodzący w jednostkowym czasie. 

Ruch ciała w polu dowolnej siły centralnej. 

Przyjmując identyczne założenia jak poprzednio zobaczymy jak wygląda ruch w polu siły 

centralnej na przykład F ~ 1 . W ruchu takim obowiązują identyczne zasady zachowania jak 

r 

poprzednio. Wartość energii jest taka, że ruch odbywa się w przedziale 〈r 1, 

r 2 

〉 . oznacza to, że w 

płaszczyźnie prostopadłej do J ruch odbywa się wewnątrz pierścienia ograniczonego przez 

okręgi o promieniach r 1 i r 2 . Co więcej, w odległości r 1 i r 2 od centrum siły wartość 

prędkości radialnej równa jest zeru v r 

=0 . Zatem tor takiego ciała jest styczny do obu okręgów 

ograniczających pierścień dozwolonego ruchu [6],[9] (patrz plik ruch_w_pol_centr.py). Gdy 

symulacja będzie trwała odpowiedni okres czasu zobaczymy, że trajektoria planety przebiega przez 

47

obszar takiego właśnie pierścienia. 

Rysunek 38: Ruch w polu siły centralnej proporcjonalnej do 1/r 

Układ podwójny planet. 

Nie wszystkie układy planet zachowują się jak te przedstawione w poprzednich symulacjach. 

Istnieje bowiem cała gama planet o porównywalnych masach tzw. planet podwójnych. Przykładu 

takiego nie należy szukać zbyt daleko gdyż porównywalne rozmiary i masy Ziemi i Księżyca 

skłaniają nas do traktowania obydwu tych fizycznie związanych obiektów jako planety podwójnej. 

W pozostałych przypadkach z jakimi mamy do czynienia w układzie planetarnym Księżyce są 

tworami innej rangi niż ich macierzyste planety. Planeta podwójna Ziemia-Księżyc ma masę 

6,0485⋅10 24 kg z czego na Ziemię przypada 98,78%. Średnica Księżyca wynosi ponad 27% 

średnicy ziemskiej. Dzięki silnym więzom grawitacyjnym obydwa ciała obiegają wspólny środek 

masy w okresie miesiąca gwiazdowego ( 27 d ,3217 ) . Środek masy układu Ziemia-Księżyc 

znajduje się wewnątrz Ziemi, średnio 4671 km od jej środka w kierunku Księżyca. Kolejna 

symulacje jakie zostaną zaprezentowane uwzględniają oddziaływania grawitacyjne pomiędzy 

obiektami o porównywalnych masach. W analogiczny sposób zostały w nich zaimplementowane 

algorytmy rozwiązywania równań różniczkowych zwyczajnych metodą Eulera (patrz plik 

ruch_planet_podw_A.py). W jednej z nich parametry planet zostały tak dobrane aby środek masy 

układu pozostawał w spoczynku, w drugiej natomiast porusza się ze stałą prędkością. 

48

Rysunek 39: Symulacja trajektorii ruchu dla układu planet podwójnych. Środek masy znajduje się w spoczynku (z 

lewej) oraz środek masy porusza sie ruchem jednostajnym (z prawej). 

Ruch wielu planet z uwzględnianiem wzajemnego oddziaływania 

grawitacyjnego między sobą. 

Nieco trudniejszym zagadnieniem jest rozpatrywanie ruchów planet wchodzących w skład 

niewielkiego układu planetarnego na przykład złożonego z trzech lub więcej ciał 

o porównywalnych masach [7]. W każdym kroku czasowym będzie do wykonania większa ilość 

obliczeń, dlatego korzystanie z tradycyjnych metod może okazać się nieefektywne. Aby 

przyspieszyć nieco obliczenia do przechowywania danych wykorzystane zostaną tablice. Zobaczmy 

jak wygląda główna struktura algorytmu ruchu. 

Rozpoczynamy od określenia liczby ciał wchodzących w skład układu planetarnego oraz określenia 

ich położeń, mas i prędkości początkowych. Oprócz tego opcjonalnie możemy nadawać inne 

atrybuty na przykład nazwy poszczególnych ciał, określić kolory etc. 

#liczba cial bioracych udzial w symulacji 

n_of_bodies = 3 

# nadanie polozen poczatkowych 

pos=array([[-2.5,0.0,0.0],[-1.136366, -0.00017964, 0.],[2.5,0.0,0.0]]) 

# nadanie mas 

lista_mas=[30.0, 0.01, 25.0] 

m = array(lista_mas) 

#nadanie predkosci poczatkowych 

vel=array([[0.0,-1.8,0.0],[0.0,-5.4,3.5],[0.,2.16,0.0]]) 

Należy pamiętać, że listy zawierające parametry początkowe muszą ściśle odpowiadać liczbie ciał 

biorących udział w symulacji i tak zmieniając liczbę ciał do 4 musimy zmodyfikować listę położeń 

na przykład do postaci: 

pos=array([[-2.5,0.0,0.0],[-1.136366,0.00017964,0.], [2.5,0.0,0.0], 

[3.5,0.0,1.0]]) 

W analogiczny sposób postępujemy z pozostałymi listami zawierającymi parametry początkowe. 

Przyjrzyjmy się nieco bliżej funkcji big_movable() odpowiedzialnej za wyznaczanie przyspieszenia 

prędkości i położenia w każdym kroku czasowym symulacji. Dla naszego układu planetarnego 

49

ównanie ruchu przybiera następującą formę: 

N 

d v 

m 

i 

i 

dt = ∑ − G m m x – i j i x j 

3 

j=1 r ij 

Symbol ∑ oznacza sumowanie po wszystkich wartościach j (po wszystkich pozostałych 

ciałach niebieskich) z wyłączeniem j=i , natomiast r ij to odległość między i-tą i j-tą planetą, 

którą wyznaczamy w następujący sposób: 

r ij 

= x i 

– x j 

2 y i 

– y j 

2 z i 

– z j 

2 

Więc przyspieszenie i-tej planety będzie wynosiło: 

N 

a i 

=∑ 

3 

j=1 r ij 

Stosując zmodyfikowaną metodę Eulera otrzymamy: 

v i 

tdt /2= v i 

t−dt/2 dt a i 

t 

x i 

tdt= x i 

tdt v i 

tdt /2 


v i 

dt /2=v i 

t 0 

dt /2 a i 

t 0 

 

Zobaczmy jak wygląda implementacja takiego algorytmu. Dla chwili początkowej tj. t=0 s 

musimy wyznaczyć przyspieszenie działające na każdą z planet. Zatem w pierwszej kolejności 

obliczane są wzajemne odległości między tymi obiektami, najpierw w postaci wektorów a następnie 

w postaci skalarów. 

− G m j x i – x j 

def big_movable(): 

global pos,vel,vel_posrednia,acc 

if czas==0: 

b=pos[:,NewAxis]-pos #odległości w formie wektorów (każda z każdą) 

R_distans = sqrt(add.reduce(b*b,-1)) #odległości w formie skalarów 

(każda z każdą) 

acc_big_new=(-G*m)/(R_distans**3) 

Kolejno przypisujemy wartości zerowe przyspieszenia pomiędzy i-tą i i-tą planetą 

for i in arange(n_of_bodies+1): 

acc_big_new[i,i]=0#jest nieskonczona no ale...na potrzeby obliczeń = 0 

a także wyznaczamy wypadkowe przyspieszenie działające na każdą z planet oraz prędkość 

pośrednią 

acc_in_algorithm=[] 

for k in arange(n_of_bodies+1): 

for f in arange(n_of_bodies+1): 

acc_in_algorithm.append((b[k][f])*acc_big_new[k][f]) 

acc[k]=sum(acc_in_algorithm) #wyznaczenie wypadkowego przyspieszenia 

acc_in_algorithm=[] #wyzerowanie zmiennej 

V_new = vel 

S_new = pos 

V_posr_inalgorithm= vel + (dt/2)*acc 

W ostatniej fazie musi nastąpić podstawienie nowych wartości prędkości i położenia dla zmiennych 

oraz aktualizacja położenia dla każdej z planet. Taka forma algorytmu pozwala na przeprowadzanie 

symulacji bez konieczności aktualizowania położeń wyświetlanych planet. Opcja taka może okazać 

się pomocna przy przeprowadzaniu obliczeń na komputerach o niewielkiej mocy obliczeniowej 

procesora graficznego. 


objekt_list[i].frame.pos=S_new[i] 

50

vel = V_posr_inalgorithm 

vel_posrednia = V_posr_inalgorithm 

pos = S_new 

Analogicznie przeprowadzane są obliczenia dla kolejnych kroków czasowych. Tak zdefiniowany 

algorytm ruchu pozwala na nadawanie dowolnych prędkości co pozwala obserwować trajektorie 

dowolnie zorientowane w przestrzeni. 

else: 

b=pos[:,NewAxis]-pos 

R_distans = sqrt(add.reduce(b*b,-1)) 

acc_big_new=(-G*m)/(R_distans**3) 


acc_big_new[i,i]=0 #jest nieskonczona no ale... dla obliczeń 

przyjmuje 0 


for k in arange(n_of_bodies+1): 

for f in arange(n_of_bodies+1): 

acc_in_algorithm.append((b[k][f])*acc_big_new[k][f]) 

acc[k]=sum(acc_in_algorithm) 


vel_posrednia= vel_posrednia + dt*acc 

vel=vel_posrednia 

S_new = pos + vel_posrednia*dt 


objekt_list[i].frame.pos=S_new[i] 

pos = S_new 

Dodatkowe algorytmy jakie znajdują się w tej funkcji służą do wyznaczenia środka masy układu, 

aktualizacji krzywych wizualizujących wzajemne odległości między planetami oraz środkiem masy 

a także dodaniu trajektorii dla każdej z planet. 

51

8. Wybrane zagadnienia fizyczne 

Sprężyny i tłumienie drgań. 

Sprężyny stanowią elementy strukturalne amortyzatorów i tłumików. Często służą do połączenia 

dwóch ciał i wówczas mogą wywierać na nie siły równe i przeciwnie skierowane. Siły te zależą 

między innymi od współczynnika sprężystości oraz od długości rozciągnięcia lub ściśnięcia 

sprężyny (długości względnej). Określana jest ona często zależnością F s 

=k s 

L−r gdzie F s 

jest siłą sprężystości, k s współczynnikiem sprężystości, L długością rozciągniętej lub 

ściśniętej sprężyny. 

W przypadku symulacji numerycznych wraz z elementami sprężystymi [3],[5],[7] stosuje się 

elementy tłumiące drgania tak zwane amortyzatory lub tłumiki. Służą one tłumieniu drgań a efekt 

ich działania podobny jest do sił oporu spowodowanego na przykład lepkością. Gdy dwa ciała 

zbliżające lub oddalające się od siebie zostaną połączone przy pomocy elementu tłumiącego, jego 

działanie będzie powodować zmniejszanie prędkości względnej. W najprostszych przypadkach 

przyjmuje się, że siła ta jest proporcjonalna do względnej prędkości ciał połączonych ze stałą 

proporcjonalności k tł co wyrażamy następująco: 

F tł 

=k tł v 1 

−v 2 

Jest to siła tłumiąca czyli funkcja współczynnika tłumienia k tł i względnej prędkości ciał 

(punktów materialnych). Najczęściej sprężyny i tłumiki są połączone w jeden element 

sprężynująco-tłumiący. Siły wywierane przez taki element opisywane są wspólnym wzorem, 

określającym siłę będącą kombinacją siły sprężystości i tłumienia. Co zapisujemy w postaci: 

F 1 

=−{ k s 

L−r k tł [ v 1 − v 2 ⋅L ] 

L 

} L 

L 

gdzie F 1 - jest siłą wywieraną na ciało pierwsze, zaś siła F 2 wywierana na ciało drugie 

zgodnie z trzecią zasadą dynamiki dana jest wzorem: 

F 2 

=− F 1 

Nim skonstruowany zostanie taki element sprężynująco-tłumiący przedstawiony zostanie model, 

w którym siła działająca jest proporcjonalna do odchylenia i skierowana w przeciwnym kierunku, 

czyli model przedstawiający zachowanie ciężarka zawieszonego na idealnej sprężynie bez 

jakiegokolwiek tłumienia ruchu. Druga zasada dynamiki przyjmuje więc postać: −kx=m d v y 

dt 

Prędkość w kierunku y zmienia się z szybkością proporcjonalną do samego y. Stałe liczbowe nie 

wniosą nic specjalnie ciekawego, więc można przyjąć, że zmieniliśmy skalę czasu lub że jakoś 

zmieniliśmy układ jednostek, tak by k /m=1 . Pozostanie zatem do rozwiązania numerycznego 

dv 

równanie następującej postaci: 

y 

=−y . Przyjmujemy następujące warunki początkowe 

dt 

t=0 , y=1 , v y 

=0 i konstruujemy algorytm oparty o zmodyfikowaną metodę Eulera: 

dt 

ytdt = ytdt vt 2 

dt 

vt 2 =v dt 

t− 

2 dt a t 

at =−y 

52


v dt 

2 =vt 0 dt 

2 at 0 

Pozostaje jeszcze implementacja funkcji pozwalającej ocenić dokładność rozwiązań numerycznych. 

d 2 y 

Ogólne rozwiązanie równania 

dt =− k 2 m y 

lub zapisanego w innej postaci jako 

y= Acos 0 t Bsin 0 t 

gdzie A=a cos , B=−a sin 

d 2 y 

dt =− 2 2 0 y wyraża się następująco: 

Po uwzględnieniu założeń zależność położenia od czasu określona będzie równaniem 

y=cost , 

prędkość 

dy 

dt =−sin t , 

a przyspieszenie 

d 2 y 

dt =−cost . 

2 

Tabela. Wyniki symulacji dla ciała zawieszonego na idealnej sprężynie przy braku czynnika 

tłumiącego (plik 02sprezyna_ideal.py). 

t y v y a y y prec v y prec a y prec 

0.0 1.0 0.0 -1 1.0 0.0 -1 

-0.05 -0.0499791692707 

0.1 0.995 -0.995 0.995004165278 -0.995004165278 

-0.1495 -0.149438132474 

0.2 0.98005 -0.995 0.980066577841 -0.980066577841 

-0.247505 -0.247403959255 

0.3 0.9552995 -0.9552995 0.955336489126 -0.955336489126 

-0.34303495 -0.34303495 

0.4 0.920996005 -0.920996005 0.921060994003 -0.921060994003 

-0.4351345505 -0.434965534111 

0.5 0.87748254995 -0.87748254995 0.87758256189 -0.87758256189 

-0.522882805495 -0.522687228931 

0.6 0.825194269401 -0.825194269401 0.82533561491 -0.82533561491 

-0.605402232435 -0.605186405736 

0.7 0.764654046157 -0.764654046157 0.764842187284 -0.764842187284 

-0.681867637051 -0.681638760023 

0.8 0.696467282452 -0.696467282452 0.696706709347 -0.696706709347 

-0.751514365296 -0.75128040514 

0.9 0.621315845922 -0.621315845922 0.621609968271 -0.621609968271 

-0.813645949888 -0.813415504789 

1.0 0.539951250934 -0.539951250934 0.540302305868 -0.540302305868 

-0.867641074982 -0.867423225594 

1.1 0.453187143435 -0.453187143435 0.453596121426 -0.453596121426 

-0.912959789325 -0.912763940261 

1.2 0.361891164503 -0.361891164503 0.362357754477 -0.362357754477 

53

t y v y a y y prec v y prec a y prec 

-0.949148905775 -0.948984619356 

1.3 0.266976273925 -0.266976273925 0.267498828625 -0.266976273925 

-0.975846533168 -0.975723357827 

1.4 0.169391620609 -0.169391620609 0.1699671429 -0.1699671429 

-0.992785695229 -0.992712991038 

1.5 0.0701130510857 -0.0701130510857 0.0707372016677 -0.0707372016677 

-0.999797000337 -0.999783764189 

1.6 -0.0298666489481 0.0298666489481 -0.0291995223013 0.0291995223013 

Rozwiązania równania 

Zmodyfikowana metoda Eulera. 

dv y 

dt =−y dla kroku czasowego dt=0.1 . parametry początkowe y 0 

=1 , v 0 

=0 , k=1 

Analiza wyników w powyższej tabeli pozwala stwierdzić że zgodność pomiędzy wynikami 

symulacji i wynikami dokładnymi zachodzi z dokładnością do trzech cyfr znaczących. 

By symulacja wyglądała nieco bardziej realistycznie wykonane zostało połączenie tych dwóch 

punktów przy pomocy sprężyny. Linia 

sprężynowa (lub śrubowa jak często też bywa 

nazywana) jest krzywą przestrzenną opisaną na 

powierzchni walca przez punkt poruszający się 

w ten sposób, że stosunek jego przemieszczenia 

liniowego (wzdłuż osi) a do odpowiadającego 

mu przemieszczenia kątowego jest stały, 

ale różny od zera lub nieskończoności. 

Powstawanie takiej krzywej można zobrazować 

przez nawinięcie na powierzchnię walca prostej 

nachylonej do jego podstawy pod kątem , 

zwanym kątem wzniosu. Jest to kąt ostry 

zawarty między styczną do linii śrubowej a 

płaszczyzną prostopadłą do osi linii śrubowej. 

Odległość osiową między dwoma sąsiednimi 

punktami przecięcia linii śrubowej z tworzącą 

walca nazywa się skokiem linii śrubowej. 

Rysunek 40: Powstawanie linii śrubowej dla sprężyny o 

jednym zwoju. 

Jeżeli sprężyna będzie zawierać n 0 zwojów to oznaczając przez L 0 długość nierozciągniętej 

sprężyny o n 0 zwojach, =2 n 0 , R 0 promień nierozciągniętej sprężyny, otrzymamy 

 

2 

związek L rect 

=L 2 0 

R 0 

2 a po przekształceniu L rect 

=L 1 0 

R 0 

. 

L 0 

Otrzymana zależność pozwala określić długość drutu z którego jest wykonana sprężyna. Wraz z 

rozciągnięciem sprężyny zmienia się jej promień. Oznaczając przez R aktualny promień 

sprężyny a przez L długość rozciągniętej lub ściśniętej sprężyny możemy napisać: 

R 2 L 2 2 

= L rect 

. Obliczając R z ostatniego związku dostaniemy zależność pozwalającą 

określić jaka jest długość promienia przy rozciągnięciu (ściśnięciu) sprężyny. 

2 

 

54

Kolejna symulacja ilustruje trudniejszy problem 

mechaniki, który poza tym dodaje poprzedniemu 

cech realizmu. Uwzględnijmy zatem opory ruchu. 

Istnieje wiele sytuacji, w których siła tarcia jest 

proporcjonalna do szybkości, z jaką porusza się ciało. 

Przykładem może być tarcie, pojawiające się przy 

wolnym ruchu ciała w oleju lub innej gęstej cieczy. 

Gdy ciało spoczywa wówczas nie występuje siła 

oporu. Jednak im szybciej się porusza,tym szybciej 

opływa je olej i tym większy jest opór. Zakładamy 

więc, że na ciało działa jeszcze jedna siła oporu 

proporcjonalnego do prędkości F tł 

=k tł v 1 

−v 2 zaś 

siła będzie równa 

F =−{ k s L−r k tł [ v 1 − v 2 ⋅L] 

} L 

L L . 

Wystarczy zatem wprowadzić kolejną zmienną – 

współczynnik tarcia oraz zaimplementować 

powyższy wzór na siłę (patrz plik 

03sprezyna_z_tlumikiem.py). 

Rysunek 41: Ściskanie i rozciąganie sprężyny 

powoduje zmianę jej promienia. 

Rysunek 42: Symulacja ruchu ciała zawieszonego na sprężynie przy współczynniku oporu ośrodka 

proporcjonalnym do prędkości. Całkowanie zmodyfikowana metoda Eulera. 

55

Waga. 

Poprzednią symulację można nieco uatrakcyjnić dodając skalę, na której można odczytać wagę 

ciała zawieszonego na sprężynie. 

Jeżeli oznaczymy długość sprężyny przez L spring to położenie równowagi statycznej końca 

sprężymy obciążonego ciałem o masie m wynosi 

h=L spring 

mg 

gdzie k s 

k s 

oznacza współczynnik sprężystości. 

W oparciu o tą zależność została skonstruowana funkcja rysująca skalę liniową wagi. Zmieniając 

wartość przyspieszenia grawitacyjnego, stałą sprężystości oraz długość sprężyny zmieniać się 

będzie zarówno skala wagi jak i miejsce rysowania tej skali. 

Rysunek 43: Waga 

56

Wahadło torsyjne. 

Wahadłem takim może być na przykład krążek zawieszony w środku masy. Drut na którym wisi 

krążek, jest sztywno zamocowany z obu stron w taki sposób by niemożliwe było ślizganie się. Jeśli 

krążek obrócimy w płaszczyźnie poziomej do położenia oznaczonego na poniższym rysunku żółtą 

strzałką, to drut zostanie skręcony. Wówczas na krążek będzie działać moment siły skręconego 

drutu i układ taki będzie dążył do położenia równowagi czyli takiego by położenie kątowe było 

równe zeru. Moment ten jest proporcjonalny do wielkości skręcenia: =− . Jest to prawo 

Hooke'a. Stała jest nazywana stałą skręcenia [8]. Równanie ruchu dla takiego układu 

przyjmuje postać: 

= I d 2 

dt 2 k tł 

d 

dt 

. 

Widać zatem, że to równanie jest podobne do równania opisującego liniowy ruch harmoniczny z 

tłumieniem, którego symulacja była poprzednio omawiana. 

Wiele przyrządów pomiarowych zawiera w sobie wahadło torsyjne na przykład galwanometry, lub 

waga Cavendisha. Innym przykładem ruchu harmonicznego tłumionego może być ruch balansu w 

zegarkach. Gdy zabraknie przywracającego równowagę momentu siły, pochodzącego od spiralnego 

włosa-sprężyny, w wyniku tarcia ruch taki zaniknie. 

W tej symulacji dla uproszczenia została pominięta wizualizacja drutu (lub spiralnego włosa 

sprężyny), natomiast zaimplementowane zostały następujące metody całkowania numerycznego: 

zmodyfikowana metodą Eulera, metoda punktu środkowego oraz metoda Rungego-Kutty czwartego 

rzędu. 

Rysunek 44: Symulacja ruchu harmonicznego tłumionego. Metoda Rungego-Kutty. 

57

Zderzenia ciał z przeszkodami - zderzenie kul w przestrzeni 

Od wielu lat zjawiska zderzeń ciał lub elementów tych ciał (cząstek) są przedmiotem 

niegasnącego zainteresowania wśród naukowców. W miarę rozwoju współczesnej techniki 

i inżynierii materiałowej zaczęto zajmować się szerokim spektrum dynamicznych obciążeń ciał 

takich jak uderzenia fragmentów komet lub innych obiektów kosmicznych w obudowę statku lub 

sondy kosmicznej, wielokrotne uderzenia kropel cieczy w twarde elementy konstrukcyjne, 

zderzenia ciał niesionych przez huragany i tornada z obiektami stacjonarnymi itp. Również 

zderzenia cząstek elementarnych z materią odgrywają we współczesnej fizyce niebagatelną rolę, 

ponieważ dzięki badaniom tego typu możliwe jest poznanie podstawowych składników materii i ich 

oddziaływań. Kolejna symulacja jaka zostanie zaprezentowana pokaże w jaki sposób symulować 

nierelatywistyczne zderzenia punktów materialnych a także ciał sztywnych. 

Pod pojęciem „zderzenie” należy rozumieć krótkotrwałe oddziaływanie zwykle dwóch ciał 

(cząstek elementarnych, atomów, brył sztywnych), zbliżonych na dostatecznie małą odległość, które 

powoduje zmianę kierunku ich ruchu [3]. Zmiana liczebności, stanu wewnętrznego i rodzaju 

elementów oddziałujących ze sobą, w rozpatrywanym zjawisku nie będzie brana pod uwagę. 

Jako przykład posłuży nam zderzenie kul. Obiekty te będziemy traktować zgodnie z klasycznymi 

zasadami Newtona. Zderzające się ciała, niezależnie od materiału i budowy traktujemy jak 

jednorodne bryły sztywne. Również w trakcie i w wyniku zderzeń nie będą one zmieniać kształtu. 

Jest to oczywista idealizacja, gdyż w rzeczywistości zderzające się ciała wgniatają się, często może 

dochodzić w nich do wewnętrznych spękań i mikro lub makro uszkodzeń, trwale zgniatają się 

a nawet zapadają lub rozpadają na większą ilość elementów. 

Siły występujące pomiędzy zderzającymi się obiektami nazywa się siłami impulsowymi. Siły 

występujące w przypadku uderzenia bili kijem bilardowym, lub kopnięcia piłki są także siłami 

impulsowymi. Zasady dynamiki Newtona będą stanowiły fundament technik zastosowanych w tej 

symulacji. Siłę działającą na ciało możemy zapisać jako F = d p a po scałkowaniu po czasie 

dt 

otrzymujemy ∫ 

t 

t 0 

t 

F dt=∫ 

t 0 

d p 

dt 

t 

zatem ∫ 

t 0 

F dt= p 

t 

Wektor ∫ F dt nazywa się impulsem (lub popędem) siły w przedziale czasu t=t – t 0 . 

t 0 

Mówiąc dokładniej, impuls (popęd) jest wektorem równym zmianie pędu, czyli zmiana pędu jest 

równa użytemu popędowi siły. Jeżeli masa ma stałą wartość to możemy napisać: 

t 

impuls liniowy=∫ F dt=m v final 

−v initial . Taki oto impuls działa na ciało podczas zderzenia. Na 

t 0 

potrzeby symulacji poczynimy jednak dodatkowe uproszczenia, które uproszczą zagadnienie jednak 

efekty będą nadal interesujące. 

W modelowaniu przebiegu zjawiska zderzenia możemy wyróżnić dwie fazy. Pierwsza z nich 

dotyczy ruchu ciał przed zderzeniem i kończy się (z reguły) detekcją zderzenia, która daje 

odpowiedź na pytania czy nastąpiło zderzenie, a w przypadku odpowiedzi twierdzącej pozwala na 

ustalenie miejsca kolizji. Jest to zatem problem czysto geometryczny. Druga faza to odpowiedź 

zderzenia. Jest to problem fizyczny ruchu ciał po zderzeniu. Bazuje on na algorytmie detekcji 

zderzenia więc dokładne wyznaczenie odpowiedzi zderzenia zależy od precyzji i niezawodności 

algorytmu detekcji. Dla uzyskania szybkości działania zastosowana zostanie metoda detekcji 

za pomocą kul otaczających, która jest niezwykle prosta w implementacji. 

Analiza odpowiedzi zderzenia obejmuje zarówno uwzględnienie newtonowskiej zasady zachowania 

58

pędu jak i zmianę pędu równą impulsowi działających sił. Pierwsza z nich mówi, że w układzie 

izolowanym w przypadku gdy masy ciał są stałe, to suma iloczynów mas i prędkości przed 

zderzeniem jest równa sumie iloczynów mas i prędkości po zderzeniu 

∑ m i v i initial 

=∑ m i v i final . 

Poza tym przyjmuję się, że jedyną siłą mającą tu znaczenie jest siła impulsowa. Wszystkie inne siły, 

które działają w chwili zderzenia są pomijalnie małe. Z doświadczenia wiemy, że w zderzeniu 

rzeczywistym energia kinetyczna jest tracona na energię odkształceń, rotacji lub oscylacji. Jeżeli 

deformacja jest trwała to następuje strata energii a zderzenie nazywamy niesprężystym, ponieważ 

odpowiedź zderzeniowa czyli ruch kul po zderzeniu i związana z nią energia są mniejsze niż przed 

zderzeniem. Jeżeli zderzenie jest idealnie niesprężyste to obiekty po zderzeniu zazwyczaj poruszają 

się jako jedno ciało a prędkość ciał po zderzeniu jest średnią ważoną ich prędkości początkowych, 

przy czym wagami są masy tych ciał. Przykładem takiego zderzenia mogą być kule wykonane 

z kitu technicznego lub plasteliny. Rozpatrując czysto teoretyczne zderzenie brył sztywnych 

możemy rozpatrywać straty energii lub nie. Jeżeli nie rozpatrujemy strat energii to mówimy, że 

energia jest zachowana. Dobrym przykładem zderzenia sprężystego, lecz nie idealnie sprężystego 

jest zderzenie kul bilardowych lub stalowych. W takim zderzeniu w normalnych warunkach 

deformacje kul są nietrwałe i pomijalne małe. Zatem zderzenia rzeczywiste są czymś pośrednim 

pomiędzy zderzeniem idealnie sprężystym i idealnie niesprężystym. Dlatego dla ciał sztywnych 

wprowadzony musi zostać współczynnik, pozwalający określić stopień sprężystości zderzenia. 

Współczynnik taki będzie określał iloraz względnej prędkości ciał po zderzeniu do względnej 

prędkości tych ciał przed zderzeniem. Jeżeli w zderzeniu będą brały udział dwa ciała to 

współczynnik zderzenia (restytucji) możemy zapisać następująco: e=− v 1 final 

−v 2 final 

, 

v 1initial 

−v 2initial 

gdzie v 1 final , v 2 final prędkości po zderzeniu, natomiast v 1 initial , v 2 initial prędkości przed 

zderzeniem, przy czym należy zwrócić uwagę iż są to prędkości wzdłuż linii akcji zderzenia. 

Współczynnik taki zależy od wewnętrznej budowy, geometrii a także od materiału z jakiego są 

wykonane kolidujące obiekty. Dla zderzenia kul bilardowych wynosi 0,9 zaś dla zderzenia kija 

baseballowego i piłki wynosi zaledwie 0,43. Dla zderzeń doskonale sprężystych wynosi 1 a dla 

doskonale niesprężystych zero. Dla wszystkich zderzeń rzeczywistych, w których nie zachodzą 

reakcje egzoenergetyczne lub endoenergetyczne wartość tego współczynnika będzie przyjmować 

wartości z przedziału od zera do jeden. 

Ponadto w modelu niniejszego zderzenia przyjmuje się brak tarcia między kolidującymi obiektami, 

wynika z tego iż kule po zderzeniu nie będą rotować. W tego typu sytuacji linia akcji zderzenia jest 

prostopadła do zderzających się powierzchni. Gdy prędkości leżą wzdłuż tej prostej zderzenie nosi 

nazwę zderzenia na wprost, lub w szczególnym przypadku gdy prędkości dodatkowo będą mieć 

przeciwne zwroty to zderzenie nazywamy centralnym. Gdy prędkości nie układają się wzdłuż linii 

akcji to takie zderzenie nazywamy skośnym. Zazwyczaj zderzenia tego typu rozpatruje się 

rozkładając wektory prędkości na składowe prostopadłe i równoległe do linii akcji. Wówczas 

zderzenie będzie miało wpływ na składowe równoległe do linii akcji, nie będzie mieć natomiast 

wpływu na składowe prostopadłe do niej. 

Opis algorytmu 

Rozpoczynamy od importowania niezbędnych bibliotek, wykonania układu współrzędnych oraz 

zdefiniowania parametrów okna. Pierwszym fizycznym parametrem jaki wprowadzimy do 

symulacji jest parametr zderzenia b. Określa on odległość środka ciężkości pierwszej kuli od osi 

iksów na której będzie znajdować się druga kula, co przedstawione zostało schematycznie na 

poniższym rysunku. 

59

Rysunek 45: Sposób wyznaczania parametru zderzenia b. 

Kolejno przystępujemy do zainicjowania obiektów zderzeń czyli kul oraz nadania im atrybutów 

fizycznych takich jak prędkości, promienie i masy. Symulację wzbogacić należy również 

we współczynnik zderzenia o którym było wspomniane wcześniej. Również na samym początku 

programu należy zdefiniować krzywe, które będą obrazować trajektorie ruchu. Wreszcie nie 

możemy także zapomnieć o zdefiniowaniu kroku czasowego symulacji, który należy odpowiednio 

dobrać w zależności od prędkości nadanym kulom. 

# b - parametr zderzenia 

b = -1.2#-1.80#[m] 

ball_1 = sphere(pos=(-4.5,b,0.)) #[m] 

ball_2 = sphere(pos=(4.0,0.0,0.0)) #[m] 

ball_1.velocity = vector(4.0,0.0,0.0) #[m/s] 

ball_2.velocity = vector(-1.5,0.0,0.0) #[m/s] 

mass_1 = 15.0 #[kg] 

mass_2 = 5.0 #[kg] 

ball_1.radius=1.2 #[m] 

ball_2.radius=0.8 #[m] 

# dla coef_e=1.0 zderzenie idealnie sprezyste 

# dla coef_e=0.0 zderzenie calkowicie niesprezyste 

coef_e = 1.0 #wspolczynnik zderzenia 

ball_1.color=K_1 

ball_2.color=K_2 

# slad ruchu 

ball_1.trail = curve(color=ball_1.color,radius = 0) 

ball_2.trail = curve(color=ball_2.color,radius = 0) 

dt = 0.01 # krok czasowy symulacji 

Ruch obiektów zarówno przed zderzeniem jaki po nim jest ruchem jednostajnym prostoliniowym, 

więc by nie komplikować algorytmu do przesuwania obiektów zostanie użyta metoda Eulera. Jest to 

realizowane z użyciem pętli while. 

while 1: 

rate(50) 

#ruch kulek 

ball_1.pos = ball_1.pos+ball_1.velocity*dt 

ball_2.pos = ball_2.pos+ball_2.velocity*dt 

W każdym kroku czasowym algorytm uruchamia funkcję detection(), odpowiedzialną za wykrycie 

zderzenia między obiektami. Jej działanie jest następujące. W pierwszej kolejności tworzymy 

tablice pozycje=array() oraz promienie=array() w których w każdym kroku czasowym 

60

umieszczamy aktualne położenia i promienie obiektów. Posłużą one do wyznaczenia odległości 5 

między kulami. Detekcja zderzenia nastąpi w przypadku gdy odległość pomiędzy środkami kul 

będzie mniejsza niż suma ich promieni, będzie to znaczyć, że nastąpiła penetracja między kulami 

a w zmiennej KOLIZJE pojawią się niezerowe wartości. Jeżeli pojawią się niezerowe wartości to 

tablica KOLIZJE jest przekształcana na listę. Najistotniejszym faktem na który należy zwrócić tutaj 

uwagę jest przypisanie zmiennej licznik wartości równej 1. Ma to zapobiec wielokrotnym 

wykryciom zderzenia mogącym powstać w wyniku dobrania zbyt dużego lub małego kroku 

czasowego ewentualnie błędów mogących wyniknąć z zaokrąglania liczb. Mamy zatem pewność, 

że do detekcji zderzenia dochodzi tylko raz. Zakończenie detekcji kończy się wywołaniem funkcji 

cool_collision(). 

#detekcja zderzenia 

poslist = [] #lista pozycji 

rlist = [] #lista promieni 

for i in range(1): 

ppp=ball_1.pos 

poslist.append((ppp)) 

ppp=ball_2.pos 


rrr=ball_1.radius 

rlist.append((rrr)) 

rrr=ball_2.radius 

rlist.append((rrr)) 

pozycje=array(poslist) 

promienie=array(rlist) 

dist = pozycje-pozycje[:,NewAxis]#odleglosci miedzy kulami jako wektory 

dist_mag = sqrt(add.reduce(dist*dist,-1)) # przeksztalcenie tych odleglosci 

na skalary 

KOLIZJE = less_equal(dist_mag,promienie+promienie[:,NewAxis])-identity(2) 

KOLIZJE_LIST = sort(nonzero(KOLIZJE.flat)).tolist() 

for ij in KOLIZJE_LIST: 

print 5*"ZEDRZENIE " 

#rozszyfrowanie liczb i, j 

i, j = divmod(ij,2) # rozszyfrowanie dla kul parami 

#print "i",i,"j",j 

KOLIZJE_LIST.remove(j*2+i) 

licznik=1 

cool_collision()#wywolanie funkcji 

Odpowiedź zderzenia 

Traktując kule jak bryły sztywne wykluczamy możliwość wzajemnego przenikania się tych 

obiektów, dlatego odpowiedź zderzenia zaczynamy od precyzyjnego wyznaczenia położeń, 

w których kule zetknęły się ze sobą. W tym celu wyznaczamy czas trwania penetracji obiektów. 

Znamy zarówno położenie, prędkości, promienie więc zgodnie z rysunkiem b x=R−K gdzie 

R= R 1 

R 2 , K - odległość pomiędzy kulami, zatem czas penetracji deltat wyznaczymy jako 

deltat= R− K gdzie Dvel=∣v 

Dvel 

1 

− v 2 

∣ 

5 Szczegółowo ta część algorytmu jest omówiona w III części modelu gazu doskonałego. 

61

Rysunek 46: Schemat działania algorytmu odpowiedzi zderzenia w przypadku wykrycia kolizji między 

obiektami. 

def cool_collision(): 

"""funkcja odpowiedzialna za 

obsluge kolizji pomiedzy kulami""" 

R=ball_1.radius+ball_2.radius 

K=mag(ball_1.pos-ball_2.pos) 

DV=mag(ball_1.velocity-ball_2.velocity) 

deltat= (R-K)/DV 

#skorygowanie polozen do pozycji zetkniecia ("cofniecie czasu") 

ball_1.pos = ball_1.pos-(ball_1.velocity)*deltat 

ball_2.pos = ball_2.pos-(ball_2.velocity)*deltat 

Linia akcji zderzenia przebiega wzdłuż prostej przechodzącej przez środki ciężkości obu kul co 

umożliwia wyznaczyć jednostkowy wektor normalny [2] 

n = norm(ball_2.pos-ball_1.pos) # jednostkowy wektor linii akcji 

Wyznaczenie położeń w których kule stykają się ze sobą umożliwia wprowadzenie do symulacji 

pewnych funkcji, które ułatwią analizę zderzenia. Pierwszą z nich jest funkcja linia_akcji(). Jej 

działanie opiera się na równaniu prostej przechodzącej przez dwa różne punkty O 1 

x 1, 

y 1 

oraz 

O 2 

x 2, 

y 2 

, którymi są położenia kul i pozwala narysować prostą normalną do powierzchni kul 

w punkcie zetknięcia. Kolejna funkcja perpendicular_LINE() na podstawie wyznaczonego 

jednostkowego wektora normalnego rysuje prostą styczną do kul w punkcie zderzenia. Ostatnia 

funkcja okregi() rysuje okrąg o zadanym promieniu, kolorze w wybranym miejscu układu 

współrzędnych. Warto podkreślić, że działanie tych funkcji nie wpływa w żaden sposób na przebieg 

symulacji. 

#------------------------------------ 

#wywolanie funkcji 

linia_akcji() 

perpendicular_LINE(n) 

okregi(ball_2.radius, ball_2.color, ball_2.pos[0],ball_2.pos[1]) 

okregi(ball_1.radius, ball_1.color, ball_1.pos[0],ball_1.pos[1]) 

#------------------------------------ 

Kontynuując analizę odpowiedzi zderzenia będziemy rozkładać wektory prędkości na składowe 

prostopadłe i równoległe do linii akcji. Wówczas jak zostało to wcześniej podkreślone zderzenie 

będzie miało wpływ na składowe równoległe do linii akcji, a nie będzie mieć wpływu na składowe 

prostopadłe do niej. Możemy wyznaczyć prędkość względną kul wzdłuż linii akcji 

62

V rn 

=v 1init 

⋅n 

#predkosc wzgledna kul 

#V_rn velocity relative normal 

V_rn = dot((ball_1.velocity-ball_2.velocity),n) 

print "V_rn",V_rn 

Jednak istotniejszą sprawą jest wyznaczenie składowych prędkości wzdłuż linii akcji 6 

v 1n b c 

=v 1 init 

⋅n 

v 2n b c 

=v 2 init 

⋅n 

#skladowe normalne do powierzchni w pkt. zderzenia 

#czyli rownolegle do wektora n 

V_1n_before = dot(ball_1.velocity,n) 

V_2n_before = dot(ball_2.velocity,n) 

Stosując zasadę zachowania pędu w kierunku linii akcji, będziemy mogli wyznaczyć prędkości kul 

wzdłuż linii akcji po zderzeniu 7 . 

m 1 

v 1n b c 

m 2 

v 2n b c 

=m 1 

v 1n a c 

m 2 

v 2n a c 

z powyższego równania wyznaczamy v 1n a c 

restytucji 

e=− v 1n ac 

−v 2n a c 

v 1n bc 

−v 2n bc 

ostatecznie otrzymamy 

v 2n ac 

= e v 1n bc 

−v 2n bc v 1n bc 

m 2 

/m 1 

v 2n bc 

m 2 

/m 1 

1 

a następnie podstawiamy do wzoru na współczynnik 

v 1n a c 

=v 1n bc 

m 2 

m 1 

v 2n bc 

− m 2 

m 1 

v 2n ac 

#wyznaczenie skladowych normalnych predkosci po zderzeniu 

V_2n_after = (coef_e*(V_1n_before-V_2n_before)+ 

V_1n_before+(mass_2/mass_1)*V_2n_before)/((mass_2/mass_1)+1) 

V_1n_after = V_1n_before + (mass_2/mass_1)*V_2n_before - 

(mass_2/mass_1)*V_2n_after 

W zderzeniu tym nie uwzględniamy tarcia, więc kule zachowują prędkości prostopadłe względem 

linii akcji. 

v 1n contact 

=v 1 init x 

⋅n y 

v 2n contact 

=v 2 init x 

⋅n y 

Następnie zapisujemy wektory prędkości obu kul po zderzeniu po rozkładzie na składowe styczne 

i normalne po czym dokonujemy przejścia do układu współrzędnych x y. Ostatecznie prędkości kul 

po zderzeniu zapiszemy jako: 

v 1 =v 1n a c cosv 1n contact sin iv 1n a c sin −v 1n contact cos j 

v 2 =v 2n a c cosv 2n contact sin iv 2n a c sin −v 2n contact cos j 

6 skrót b c (ang. before collision) – przed zderzeniem 

7 skrót a c (ang. after collision) – po zderzeniu 

63

gdzie =atan n y 

n x 

działanie funkcji cool_collision() kończy ponowne skorygowanie położeń, tym razem już z nowymi 

prędkościami jakie uzyskały kule po zderzeniu. 

# zderzenia bez tarcia, wiec ciala zachowuja predkosci prostopadle wzgledem 

wektora n 

V_1n_contact = ball_1.velocity*n[1] 

V_2n_contact = ball_2.velocity*n[1] 

alfa = atan(n[1]/n[0]) 

alfa_deg = degrees(alfa) 

# przejscie do ukladu xy 

V_1_new_x = V_1n_after*cos(alfa) + V_1n_contact[0]*sin(alfa) 

V_1_new_y = V_1n_after*sin(alfa) - V_1n_contact[0]*cos(alfa) 

V_2_new_x = V_2n_after*cos(alfa) + V_2n_contact[0]*sin(alfa) 

V_2_new_y = V_2n_after*sin(alfa) - V_2n_contact[0]*cos(alfa) 

ball_1.velocity=vector(V_1_new_x,V_1_new_y,0.0) 

ball_2.velocity=vector(V_2_new_x,V_2_new_y,0.0) 

#skorygowanie polozen i "cofnietego czasu" 

ball_1.pos = ball_1.pos+(ball_1.velocity)*deltat 

ball_2.pos = ball_2.pos+(ball_2.velocity)*deltat 

return 

Pozostałe funkcje służą wizualizacji układu współrzędnych, układu odniesienia oraz wyświetlaniu 

napisów i kontrolowaniu parametrów okna. 

Rysunek 47: Przykładowa symulacja zderzenia kul. 

Wizualizacja takiego modelu może okazać się pomocna w zrozumieniu przebiegu zjawiska 

zderzenia się ciał co ułatwi właściwe modelowanie podobnych lub bardziej zaawansowanych 

sytuacji zderzeń. Wyniki symulacji mogą być wykorzystane i porównane z wynikami fizycznych 

eksperymentów. 

64

Inne sytuacje jakie mogą być symulowane przy pomocy tej techniki. 

Z mechaniki klasycznej wiadomo, że jeżeli na środek wahań wahadła fizycznego zadziałamy siłą 

impulsową na przykład skierowaną poziomo w płaszczyźnie drgań to w punkcie zawieszenia nie 

pojawi się siła reakcji [8],[A]. Z uwagi na tą interesującą właściwość środek wahań jest nazywany 

środkiem uderzenia. I tak na przykład gdy zadziałamy siłą impulsową na walec w punkcie COP 8 to 

w punkcie zawieszenia nie pojawi się siła reakcji. 

Współrzędne punktu COP dla walca wyliczamy w następujący sposób: 

R -promień walca, l -długość walca, M -masa walca 

I = MR2 

4 Ml 2 

12 Ml 2 

4 = MR2 

4 Ml 2 

moment bezwładności względem osi przechodzącej przez 

3 

jeden z końców walca, prostopadłej do walca 

L COP 

= I gdzie d – odległość osi obrotu od środka masy 

Md 

L COP = 1 2 

R 2 

l 2 3 l 

Rysunek 48: Tylko zadziałanie silą impulsową w punkcie 

środka uderzenia nie wywołuje siły reakcji w punkcie 

zawieszenia. 

Przyjmując założenie, że kula uderza w środek uderzenia takiego walca możemy rozpatrywać 

zderzenia kuli z walcem (a nawet kijem baseballowym). W tym ostatnim przypadku zakładamy, że 

kij może swobodnie się obracać i przesuwać wokół punktu położonego w pobliżu uchwytu oraz, że 

prędkość piłki i kija w chwili uderzenia jest również pozioma. 

Uwaga: 

– Wyświetlane wartości kątów należy odczytywać jako: wartość bezwzględna kąta mniejszego 

pomiędzy trajektorią wylotu a osią iksów. 

– Parametr zderzenia b jest aktualny tylko wtedy gdy igrekowa i zetowa składowa położenia kuli 

numer 2 jest równa zeru (to znaczy zderzenie musi odbywać się w płaszczyźnie x y). 

8 COP- center of percussion (ang. środek uderzenia), COG – center of gravity (ang. środek masy) 

65

Model gazu doskonałego. 

Na podstawie projektów umieszczonych na stronie Australian National University 

pt. „Using VPython to Simulate a Ball Bouncing in a Box” oraz 

„Using VPython to Simulate a Gas” które wykonali Sally Lloyd i Stephen Roberts 

(tłumaczenie i poprawki Marcin Maćkowicz) 

Wprowadzenie 

W tym rozdziale omówiony zostanie problem komputerowego modelowania zachowania się 

gazu doskonałego w zamkniętym naczyniu. 

W pierwszej części zostanie przedstawione jak wymodelować odbijającą się kulkę (atom) 

wewnątrz sześciennego pojemnika [B], aby na podstawie tak stworzonej animacji można 

było wykonać symulację fizyczną zachowania się gazu doskonałego w zamkniętym 

naczyniu [C]. 

Wizualizacja takiego modelu może okazać się użyteczna w przypadku kiedy będziemy 

chcieli uzyskać wgląd w zachowanie się gazu wewnątrz naczynia. Napisany program, może 

okazać się także użyteczny w bardziej skomplikowanych sytuacjach na przykład gdy 

będziemy chcieli, na podstawie symulacji, przewidzieć zachowanie się gazu w fizycznym 

eksperymencie lub co jest bardziej istotne w modelu rzeczywistym. Ewentualnie możemy 

użyć wyniki w celu potwierdzenia teorii dla gazów doskonałych. 

Symulacja odbijającej się kulki wewnątrz pudełka. 

• Modelowanie poszczególnych elementów 

W pierwszej kolejności należy wykonać ściany naczynia (obiekty typu box) oraz 

zainicjować obiekt, który posłuży jako atom – w naszym przypadku będzie to kula. 

# Import biblioteki Visual 


# inicjacja sciany (lub kilku scian) 

wallR = box(pos=vector(6,0,0), length=0.2, height=4, width=4, color = 

color.red) 

# inicjacja kulki (kulek) reprezentujacych atom (atomy) 

ball = sphere(pos=vector(-5,0,0), radius=1.0, color=color.green) 

Następnie należy kuli przypisać atrybut – prędkość 

ball.velocity=vector(2,.1,0) 

66

• Przesuwanie obiektów 

Aby móc przesuwać obiekt niezbędna jest pętla, w której wielokrotnie będziemy zmieniać 

pozycję obiektu. Uzyskamy to poprzez zastosowanie nieskończonej pętli, która będzie się 

wykonywać dopóki będzie spełniony określony warunek. Ruch ten powinien być 

skoordynowany z prędkością jaką nadaliśmy obiektowi. 

• Wielokrotne odbicia piłki 

Po uruchomieniu powyższego programu zauważamy, że piłka idzie prosto przez ścianę. Aby 

mogło dojść do odbicia piłki od ściany musimy (wykonać) zaimplementować algorytm, 

który pozwoli na detekcję zderzenia atomu ze ścianką naczynia. W najprostszym przypadku 

detekcję zderzenia uzyskamy poprzez porównanie iksowej składowej położenia atomu i tej 

samej składowej ścianki naczynia. W przypadku gdy atom przesunął się poza wyznaczoną 

granicę, którą jest ściana, będzie musiało dojść do odwrócenia składowej iksowej prędkości. 

Tym sposobem zrealizujemy odbicie doskonale sprężyste. 

#sprawdzenie kolizji ze sciana 

#prawa sciana 

if ball.x > wallR.x: 

ball.velocity.x = -ball.velocity.x 

Po uruchomieniu programu zobaczyć można ruch kulki w prawo, odbicie od ściany a 

następnie ruch w lewo kontynuowany w nieskończoność. Należy podkreślić, że ten test 

logiczny nie jest zbyt wyrafinowany. Współrzędna ball.x jest środkiem atomu i współrzędna 

wallR.x jest środkiem grubości ściany, więc następuje penetracja pomiędzy ścianą i kulą 

zanim dojdzie do odbicia. 

Poprawimy znacznie naszą animację modyfikując algorytm w taki sposób aby odwrócenie 

wartości składowej prędkości nastąpiło gdy brzeg atomu sięgnie prawego brzegu ściany 

(ball.x > wallR.x-wallR.size.x/2- ball.radius) 

W następnej kolejności należy dodać kolejne ściany, a następnie zaimplementować dla kuli 

detekcję zderzenia z nimi. 

Częsty dostęp do niektórych parametrów 

obiektów wymusza zastosowanie nowych 

zmiennych (side, thk, ball_radius, maxpos) 

dzięki którym w łatwy i przystępny sposób 

parametryzujemy ściany, atom i jego 

pozycję. 

Po dodaniu wszystkich ścian niezbędne 

będzie ustawienie parametru visible na zero 

dla ściany przedniej. Zabieg ten 

wykonujemy, aby móc zobaczyć co dzieje 

się wewnątrz zbiornika. 

(patrz plik 01_kulka_w_zbiorniku.py) 

Rysunek 49: Kula wewnątrz sześciennego naczynia. 

67

Symulacja zachowania się gazu doskonałego w zamkniętym naczyniu. 

• Opis symulacji - ruch atomów 

Teraz na podstawie animacji obrazującej ruchu kulki wewnątrz zamkniętego naczynia 

zasymulujemy ruch atomów w gazie doskonałym [C]. Do tego celu będziemy potrzebować 

wiele atomów, które będą zderzać się idealnie sprężyście ze ściankami naczynia. Będziemy 

także musieli nadać pozycje i prędkości początkowe dla wszystkich atomów, ale przy 

założeniu, że wartości te będą mogły ewoluować w późniejszej fazie symulacji. W kolejnej 

fazie symulacji będziemy chcieli porównać rozkład prędkości cząsteczek gazu z rozkładem 

prędkości Maxwell'a. 

• Liczby losowe. 

Możemy uzyskać różne prędkości atomów, przy każdym uruchomieniu programu, używając 

do tego celu generator liczb losowych. Generator liczb losowych (a dokładniej 

pseudolosowych) nie jest częścią standardowego języka Python i musi by importowany 

z modułu o nazwie random. Moduł liczb losowych zawiera generatory dla kilku różnych 

rozkładów. Możemy importować tylko jednolity rozkład dla liczb losowych wydając 

polecenie: 

from random import uniform 

umieszczając je na początku programu w sekcji gdzie importujemy niezbędne biblioteki. 

Funkcja uniform(-1,1) będzie zwracać liczby losowe zawierające się w przedziale 

pomiędzy -1 i 1. Ustawienie poszczególnych składowych prędkości początkowych 

w zakresie od -2 do 2 (w jednostkach dowolnych, czyli na przykład w m/s) można wykonać 

w następujący sposób [2],[4]: 

ball.velocity=maxv*vector(uniform(-1,1),uniform(-1,1),uniform(-1,1)) 

gdzie maxv jest zmienną określającą maksymalną wartość poszczególnej składowej - w 

naszym przypadku maxv=2 

• Kontrola nad wieloma atomami 

Aby móc symulować zachowanie się gazu w zbiorniku musimy mieć wiele atomów 

wewnątrz naczynia. Jedną z prostych dróg prowadzących do łatwej i wygodnej kontroli 

parametrów dużej liczby obiektów jest umieszczenie ich w liście. 

Aby to zrobić należy zmodyfikować inicjowanie atomów do postaci: 

# inicjowanie atomow 

no_particles=10 

ball_radius=0.4 

maxpos=side-.5*thk-ball_radius 

maxv=1.0 

ball_list=[] 

for i in range(no_particles): 

ball=sphere(color=color.green,radius=ball_radius) 

ball.pos=maxpos*vector(uniform(-1,1),uniform(-1,1),uniform(-1,1)) 

ball.velocity=maxv*vector(uniform(-1,1),uniform(-1,1),uniform(-1,1)) 

68

all_list.append(ball) 

• Konstrukcja pętli for w Python jest odrobinę inna niż w wielu innych językach 

programowania [1]. Python wykonuje powtarzanie przez listę. Zatem aby otrzymać pętlę 

przechodzącą przez dany zakres liczb musimy utworzyć listę (range) liczb całkowitych 

pomiędzy 0 i liczbą atomów. 

W ten sposób otrzymamy listę nazwaną ball_list zawierającą zadaną liczbę atomów. 

Dowolny typ obiektu może by umieszczony w liście. Jeżeli uruchomimy powyższy skrypt 

zobaczymy 10 kulek wewnątrz naczynia, lecz tylko jedna z kulek (ostatnia zainicjowana 

przez pętlę) będzie się poruszać (patrz plik 02_02_gaz.py). 

Aby móc animować wszystkie atomy umieszczone w liście musimy użyć kolejnej pętli, 

która będzie przechodzić przez wszystkie elementy listy, za każdym razem aktualizując 

położenie obiektu (patrz plik 02_03_gaz.py). Pętla będzie zatem wyglądać następująco: 

while (1==1): 

# Set number of times loop is repeated per second 

rate(100) 

# Loop over list of particles 

# Move and check wall collisions 

for ball in ball_list: 

# Move ball(s) 

ball.pos = ball.pos + ball.velocity*timestep 

#check for collisions with the walls 

• Zderzenia pomiędzy między atomami. 

Można poeksperymentować z większą liczbą atomów, zmienianiem ich promieni oraz 

koloru etc. W tym momencie program pozwala kontrolować pozycję każdego z atomów 

oraz obsługuje kolizję każdego z nich w przypadku zderzenia z dowolną ścianką naczynia. 

Model ten jednakże posiada jeszcze jedną dość istotną wadę, ponieważ atomy 

przemieszczając się wewnątrz naczynia przelatują przez siebie na wzajem. Aby model ten 

stał się bardziej realistyczny musimy uwzględnić wzajemne zderzenia pomiędzy atomami. 

Różne rodzaje oddziaływań mogą być zaimplementowane w zależności od tego jaki typ 

gazu chcemy symulować. Dla gazu doskonałego zderzenia są doskonale sprężyste to znaczy 

takiego samego typu jak w przypadku zderzenia atomu ze ścianą naczynia. 

W każdym kroku pętli musimy sprawdzać czy nie nastąpiła kolizja pomiędzy atomami. Dla 

każdej pary atomów musimy sprawdzać czy odległość pomiędzy nimi jest mniejsza niż 

suma ich promieni. I tak na przykład umieszczając, na samym końcu programu czyli po 

części odpowiedzialnej za aktualizację położeń atomów, poniższy skrypt, otrzymamy 

algorytm, który będzie wykrywał kolizje pomiędzy atomami. Wcięcie dla tego skryptu 

powinno być równe z wcięciem dla funkcji rate(). 

# Ball Collision Detection 


for otherball in ball_list: 

if not ball == otherball: 

distance=mag(otherball.pos-ball.pos) 

if distance

Działanie tej części skryptu jest następujące. Dla każdego atomu umieszczonego na liście 

jest sprawdzana odległość pomiędzy danym atomem i wszystkimi innymi atomami 

sąsiednimi. Jeżeli ta odległość jest mniejsza niż suma dwóch promieni algorytm wypisze na 

ekranie słowo „collision” (ang. zderzenie) oraz poda odległość pomiędzy atomami, między 

którymi doszło do kolizji. Nie sprawdza natomiast czy doszło do zderzenia atomu samego 

ze sobą gdyż to niemiałoby sensu. Funkcja mag zwraca długość wektora (skalar) pomiędzy 

atomami. (patrz plik 02_04_gaz.py) 

Po uruchomieniu programu zauważyć można że słowo „kolizja” jest wypisywane dwa razy 

dla każdej pary atomów. Dzieje się tak dlatego, że w pętli sprawdzana jest detekcja danego 

atomu z listy każdym atomem sąsiednim. Aby sprawdzanie dla danej pary atomów nastąpiło 

tylko raz niezbędna jest modyfikacja pętli. W poprawionej wersji sprawdzanie kolizji 

następuje dla atomu o numerze indeksu „i” z atomami o numerach indeksu wyższym niż „i”. 

# Ball Collision Detection 

for i in range(no_particles): 

for j in range(i+1,no_particles): 

distance=mag(ball_list[i].pos-ball_list[j].pos) 

if distance

exchange=vj-vi 

#exchange momentum 

ball_list[i].velocity=ball_list[i].velocity + 

exchange*direction 

ball_list[j].velocity=ball_list[j].velocity - 

exchange*direction 

Funkcja norm() zwraca wektor o tym samym kierunku jak kierunek wektora wejściowego, 

ale o długości znormalizowanej do jedności. 

Zatem mając wektor a o współrzędnych x , y , z , możemy obliczyć wektor 

jednostkowy b za pomocą wzoru: b= ∣a∣ x 

∣a∣ i y 

∣a∣ j z k 

I tak na przykład pisząc: 

a=vector(3.0,4.0,0.0) 

b=norm(a) 

print b 

otrzymamy wektor jednostkowy o składowych: [0.6 0.8 0] 

Funkcja dot() zwraca iloczyn skalarny dwóch wektorów, w naszym przypadku jest to 

iloczyn skalarny pomiędzy prędkością i-tego (lub j-tego) atomu i kierunkiem linii akcji na 

której odbywa się zderzenie. 

Rysunek 50: Linia akcji zderzających się kul. 

Rozpatrzmy działanie tego skryptu na prostym przykładzie. Załóżmy, że promienie obu 

atomów są jednakowe R 1 

=R 2 

=1 , prędkość pierwszego atomu v 1 

=0.0 ,0 .0,0 .0 a 

drugiego v 2 

=−5.0 ,0.0,0 .0 , detekcja zderzenia następuje w momencie gdy atom i 

znajduje się w punkcie p 1 

=−1.34 ,−1.34 ,0 .0 a atom j w punkcie p 2 

=0.0 , 0.0 ,0.0 

odległość między atomami wynosi 1.895 , direction=−0.707 ,−0.707 ,0. , 

v i 

=0.0 , v j 

=3.536 , parametr exchange=3.536 . Nowe prędkości wyniosą 

odpowiednio: v 1 

=−2.5 ,−2.5 , 0 oraz v 2 

=−2.5 ,2.5 , 0 . 

Przeanalizowanie tego zagadnienia może stać się bardziej przejrzyste gdy rozważymy 

zderzenie centralne na wprost. 

71

Napisany program umożliwia wizualizację zachowania się 10 atomów, wewnątrz 

zamkniętego zbiornika. Nie mniej jednak nie jest to końcowa wersja programu gdyż 

modyfikacji jakich możemy dokonać jest bardzo wiele. Możemy na przykład zmieniać kolor 

atomów, które właśnie kolidują ze sobą na wzajem lub ze ścianką zbiornika (plik 

02_06_gaz_blyski.py). Należy przy tym pamiętać o zmniejszeniu kroku czasowego by 

wizualizacja dla kul, o innym kolorze trwała dłużej. Możemy także dokonywać przerwy w 

symulacji w momencie gdy następuje detekcja zderzenia i uruchamiać ponownie na 

przykład po naciśnięciu dowolnego klawisza itp. 

Warto jednak skupić się bardziej na precyzji wykonywania symulacji, gdyż posiada ona 

jeszcze jedną dość znaczącą wadę. Detekcja kolizji między atomami następuje w momencie 

gdy odległość między atomami jest mniejsza niż suma ich promieni co powoduje, że w 

wyniku błędów numerycznych (lub w wyniku inicjacji położeń atomów, która opiera się 

o algorytm losowego dobierania położeń) może dochodzić do sklejenia się atomów między 

sobą. Aby wyeliminować ten niekorzystny efekt musimy podczas każdego zderzenia 

kontrolować odległość pomiędzy atomami: (patrz plik 02_07_gaz.py) 

#adjust position 

overlap=2*ball_radius-distance 

ball_list[i].pos=ball_list[i].pos - overlap*direction 

ball_list[j].pos=ball_list[j].pos + overlap*direction 

• Szybkość wykonywania programu. 

Program, który został napisany ilustruje prosty model zachowania się atomów w gazie 

doskonałym. Możemy eksperymentować zmieniając liczbę atomów ich rozmiar a także 

średnią prędkość. Kiedy dodamy więcej atomów zauważymy natychmiast, że szybkość 

wykonywania programu znacznie spadła. Zwiększenie dwukrotnie liczby atomów powoduje 

około czterokrotne zmniejszenie szybkości wykonywania programu. Dzieje się tak dla tego, 

że liczba kroków niezbędna do sprawdzenia kolizji wzrasta z kwadratem liczby atomów. 

Wiele symulacji komputerowych opiera się o algorytmy obliczeniowe mające złożoność 

obliczeniową typu N 2 . Tego typu symulacje zawierające dużą liczbę atomów wymagają 

komputerów o dużych możliwościach obliczeniowych. 

Zwiększanie szybkości wykonywania programu może zająć większą część czasu jaki 

poświęca się na napisanie programu, dlatego nie należy lekceważyć tego problemu. 

Taktyka dla ulepszania efektywności wykonywania programu obejmuje między innymi: 

- usuwanie niepotrzebnych kalkulacji (obliczanie odległości pomiędzy atomami 

wymagające znalezienia pierwiastka kwadratowego jest bardzo pracochłonne, co znacznie 

wydłuża wykonywanie algorytmu. Sprawdzanie odległości pomiędzy atomami w celu 

wykrycia kolizji może być zrealizowane w prostszy sposób poprzez porównanie kwadratu 

odległości pomiędzy atomami co jest znacznie skróci czas wykonywania algorytmu) 

- zapisywanie wyników obliczeń zamiast wielokrotnego powtarzania ich 

- używanie bardziej wydajnych konstrukcji dla przechowywania danych (na przykład 

elementy list w pythonie nie są konieczne dla przechowywania wszystkich typów danych. 

Użycie tablic powoduje, że program staje się bardziej elastyczny w różnych zastosowaniach, 

lecz dostęp do tych danych będzie zajmował więcej czasu. Niemniej jednak tablice języka 

Python posiadają każdy element tego samego typu co powoduje, że niektóre operacje 

wykonywane na tablicach są szybsze) 

- stosowanie ulepszonych matematycznie algorytmów pozwalających używać większych 

72

kroków czasowych przy zachowaniu dużej precyzji obliczeniowej 

- minimalizację liczby atomów niezbędnych dla danego modelu 

- implementację tylko najważniejszych oddziaływań 

• Symulacja zachowania się gazu doskonałego w zamkniętym naczyniu - algorytm oparty o 

tablice przeznaczone dla szybkich obliczeń 

Najistotniejszą różnicą pomiędzy algorytmem poprzednim i obecnym jest to, że w obecnej 

wersji dane dostarczane w postaci tablic a nie jak to było wcześniej w postaci list. Jeżeli 

umieścimy je w tablicy, typ danych będzie rozpoznawany tylko raz a nie jak jest to w 

przypadku listy, za każdym razem gdy jest czytany nowy element. 

Przed pętlą odpowiedzialną za ruch atomów inicjujemy tablicę ltriang. Określa ona 

między którymi atomami będziemy musieli wyliczać kwadraty odległości. 

ltriang=fromfunction(lambda 

i,j: less_equal(j,i),[no_particles,no_particles]) 

Przesuwanie atomów odbywa się przy pomocy tej samej techniki co poprzednio (metoda 

Eulera) z tym, że obecnie wykonywane jest ono z użyciem tablicy [2]. 

pos_array=pos_array+p_array*dt 

Sprawdzanie czy nie doszło do kolizji atomu ze ścianką polega na nałożeniu maski na 

tablicę położeń. Zadaniem tej maski w pierwszym przypadku jest sprawdzanie czy pozycja 

(a bardziej precyzyjnie - którakolwiek współrzędna) atomu jest większa niż dozwolona 

odległość jaką dopuszcza zmienna maxpos i jeżeli odległość ta jest większa dla jakiegoś 

atomu, to następuje zmiana odpowiedniej składowej wektora prędkości na przeciwny oraz 

skorygowanie pozycji atomu. W ten sposób ograniczamy pozycję atomu jednocześnie w 

trzech płaszczyznach (x, y oraz z) znajdujących się w odległości maxpos od początku 

układu współrzędnych. 

# Check wall collisions 

putmask(p_array,greater(pos_array,maxpos),-p_array) 

putmask(pos_array,greater(pos_array,maxpos),2*maxpos-pos_array) 

Dopełnieniem powyższego warunku jest sprawdzanie czy poszczególne składowe położeń 

atomu nie są mniejsze niż dopuszczalna wartość -maxpos. Jest to realizowane w sposób 

analogiczny do powyższego 

putmask(p_array,less_equal(pos_array,-maxpos),-p_array) 

putmask(pos_array,less_equal(pos_array,-maxpos),-2*maxpos-pos_array) 

Detekcja zderzeń między atomami odbywa się w prostszy sposób (pod względem obliczeń) 

niż w algorytmie poprzednim. W pierwszej kolejności wyznaczamy wzajemne odległości 

pomiędzy atomami wyrażając je jako wektory 

# Check particle collisions 

separation=pos_array-pos_array[:,NewAxis] 

a następnie wyznaczamy te odległości w formie skalarów 

sepmag2=add.reduce(separation*separation,-1) 

73

#to samo możemy napisać jako: 

#sepmag2=sum(separation*separation,-1) 

Nałożenie maski na tablicę określającą, między którymi atomami należy obliczać kwadraty 

odległości 

putmask(sepmag2,ltriang,4*D2) 

Kolejnym krokiem jest wykrycie zderzenia 

hit=less_equal(sepmag2,D2) 

i dokonanie zamiany tablicy na listę, z której usuwamy zera, po czym sortujemy. 

hit_list=sort(nonzero(hit.flat)) 

Dla każdego zderzenia otrzymujemy liczbę, która po rozkodowaniu umożliwia dostęp od 

pozycji i prędkości atomów. Kolejne linie dotyczą wymiany składowych prędkości wzdłuż 

linii działania oraz modyfikacji położeń pomiędzy atomami, które zderzyły się ze sobą. 

for ij in hit_list: 

i, j = divmod(ij,no_particles) 

#print "i",i,"j",j 

sepmag=sqrt(sepmag2[i,j]) 

#print "sepmag",sepmag 

direction=separation[i,j]/sepmag 

pi=dot(p_array[i],direction) 

pj=dot(p_array[j],direction) 

exchange=pj-pi 

p_array[i]=p_array[i]+exchange*direction 

p_array[j]=p_array[j]-exchange*direction 

overlap=2*ball_radius-sepmag 

pos_array[i]=pos_array[i]-overlap*direction 

pos_array[j]=pos_array[j]+overlap*direction 

W końcu by zobaczyć działanie algorytmu musimy dokonać aktualizacji położeń 

i prędkości. (patrz plik 02_08_gaz_quick_array_full.py) 

# Update position and velocity of balls 

for i in arange(len(ball_list)): 

ball_list[i].pos=vector(pos_array[i]) 

ball_list[i].velocity=vector(p_array[i]) 

• Rozkład prędkości atomów w gazie. 

Używając obojętnie którego z tych algorytmów symulujących zachowanie się gazu 

doskonałego, będziemy potrzebowali wyciągnąć informacje jakie zwykle podajemy przy 

opisie gazu, bez konieczności przeprowadzania ciągłej obserwacji atomów odbijających się 

wewnątrz naczynia. 

Na samym początku nadaliśmy wszystkim atomom prędkości w każdym kierunku według 

jednolitego rozkładu jaki zapewnia nam funkcja uniform(). Analiza statystyczna 

podpowiada, iż bardziej prawdopodobny jest rozkład statystyczny, w którym będziemy mieli 

więcej atomów o niższej prędkości i „długi ogon” dla atomów o wyższej prędkości. 

74

Możemy zatem się spodziewać, że gaz będzie ewoluował do takiego rozkładu prędkości. 

Do wizualizacji niezbędny będzie wykres typu histogram, aby pokazać jak wiele atomów 

znajduje się w zadanym przedziale prędkości. Wykres należy zainicjować przed główną 

pętlą odpowiedzialną za aktualizację położeń atomów. 

graphwindow=gdisplay(xtitle='v_x',ytitle='N',ymax=no_particles/2) 

velocity_dist=ghistogram(bins=arange(0,2*maxv,maxv/5)) 

Zmienna velocity_dist przechowuje parametry histogramu. W tym przypadku będzie on 

posiadał dziesięć przedziałów do których zastaną przyporządkowane ilości atomów 

o zadanej przez dany przedział prędkości. Można oczywiście zmienić ilość atomów w 

zbiorniku. Wykres będzie wyświetlony w nowym oknie. Aby narysować rozkład 

składowych x-owych prędkości należy stworzyć listę zawierającą owe składowe prędkości. 

Zawarte w niej dane należy przekazać do histogramu przy pomocy funkcji plot(). 

v_list=[] 


v_list.append(abs(ball.velocity.x)) 

velocity_dist.plot(data=v_list) 

Umieszczając powyższe linie kodu wewnątrz głównej pętli zobaczymy jak rozkład 

prędkości ewoluuje w czasie. Jeżeli nie symulujemy ruchu dla wielu atomów rozkład 

prędkości będzie bardzo dynamicznie się zmieniał (patrz plik 02_09_gaz_hist_a.py). Aby 

zredukować ten mankament musimy uśrednić rozkład w czasie. Zmiana polega na 

zmodyfikowaniu parametrów wykresu a tym samym sposobu wyznaczania zmiennej 

velocity_dist. W nowej wersji powinna mieć ona postać (plik 02_10_gaz_hist_b.py): 

velocity_dist=ghistogram(bins=arange(0,2*maxv,maxv/5), accumulate=1, 

average=1) 

Pierwszy z dodanych parametrów (accumulate=1) jest odpowiedzialny za sumowanie 

danych dostarczanych w każdym kroku czasowy, natomiast drugi (average=1) wyznacza ich 

średnią arytmetyczną. Dla bardzo dużych ilości atomów fluktuacje będą nieznaczne 

i modyfikacja nie będzie konieczna. 

Jeżeli używamy szybkiej wersji programu symulującego gaz doskonały prędkości są 

przechowywane w tablicy p_array i mogą być przekształcone w histogram w następujący 

sposób: 

velocity_dist.plot(data=abs(p_array[:,0])) 

Tabela. Przykładowe iksowe składowe prędkości, jakie miały atomy w jednym z kolejnych 

kroków czasowych. 

Lp. atomu 

iksowa składowa prędkości 

1 -0.812 

2 -0.0634 

3 0.064 

4 -0.972 

5 -0.774 

6 0.132 

7 0.162 

8 -0.559 

9 0.787 

10 -0.263 

75

Otrzymany rozkład składowych prędkości będzie bardzo specyficzny ponieważ należy 

pamiętać o tym, że na histogramach tworzonych w języku Python nie mamy możliwości 

zobrazowania danych posiadających ujemne wartości. Niedogodność tą jednak można 

w prosty sposób zniwelować. Niemniej jednak chcemy tylko zobaczyć czy nadane składowe 

prędkości uzyskane z jednolitego rozkładu, w jakiś sposób ewoluowały. Pod uwagę 

bierzemy atomy posiadające składowe iksowe zarówno dodatnie jak i ujemne i wyliczamy 

dla każdej z nich jej wartość bezwzględną. 

• Porównanie z oczekiwanym wynikiem 

Wynik teoretyczny może być naniesiony na wykres w postaci krzywej. 

expected_distribution=gcurve(color=color.green) 

for vx in arange(0,2*maxv,maxv/20): 

expected_distribution.plot(pos = (vx,.27*no_particles*exp(- 

vx**2/maxv**2*3/2))) 

Powyższą część skryptu należy umieścić tuż przed główną pętla, gdyż zależność ta będzie 

nanoszona na wykres tylko raz. W przypadku gdy zmienimy liczbę przedziałów prędkości 

zależność tę będziemy musieli przeskalować. 

Rysunek 51: Porównanie wyników symulacji (niebieskie słupki) z wartością 

teoretyczną (zielona linia). 

Jak widać z powyższej ilustracji rozkład składowych prędkości uległ zmianie. Gdyby tak nie 

było, ilość atomów odpowiadająca danemu przedziałowi prędkości była by jednakowa. Już 

w modelu o tak niskim stopniu zaawansowania można zauważyć, że prędkości 

scharakteryzowane są przez pewien rozkład. Zmodyfikujmy program i w każdym kroku 

czasowym wyliczmy prędkość atomu. 

76

# Plot the velocity histogram 

v_list=[] 


#v_list.append(abs(ball.velocity.x)) 

v_list.append((sqrt(ball.velocity.x*ball.velocity.x+ball.velocity. 

y*ball.velocity.y+ball.velocity.z*ball.velocity.z))) 

velocity_dist.plot(data=v_list) 

Może to nieznacznie wpłynąć na szybkość wykonywania programu, lecz uzyskamy w ten 

sposób wykres, który w bardziej czytelny sposób pozwoli zorientować się jak kształtuje się 

rozkład prędkości w gazie. (plik 02_11_gaz_hist_c.py) 

Rysunek 52: Rozkład prędkości atomów przybiera charakterystyczny kształt krzywej Gaussa. 

• Bardziej zaawansowane symulacje. 

Możemy rozbudować program w celu symulacji bardziej złożonych problemów na 

przykład: 

- symulacji zjawiska dyfuzji dwóch gazów idealnych (patrz skrypt quicktwogas.py) 

- rozkładu prędkości w sytuacji gdy gaz składa się z atomów o różnych masach 

- symulacji zachowania się gazu w zbiorniku z ruchomym tłokiem (patrz skrypt 

quickbounce2.py) 

Inne sytuacje jakie mogą być modelowane przy użyciu podobnej techniki 

Technika śledzenia pojedynczych punktów materialnych, obliczania przyspieszeń tych 

punktów i przewidywania późniejszego położenia względem innych punktów znajdujących 

się w ruchu może być użyta w szerokiej gamie sytuacji: 

- dynamika molekuł i obliczenia z dziedziny chemii mogą tym sposobem ustalać kształt, 

częstości rezonansowe i energię wiązania molekuł. Najtrudniejszą sprawą w takich 

przypadkach jest ustalenie oddziaływań, które zależą bardzo często od względnych pozycji 

więcej niż dwóch atomów, a także od kątów między nimi 

- oddziaływania grawitacyjne wyznaczają orbity planet na przykład w układzie słonecznym. 

Precyzyjne wyznaczenie tych orbit może odpowiedzieć na pytanie czy układ planetarny jest 

stabilny czy chaotyczny, czy orbity planet mogą drastycznie się zmienić w przyszłości jeżeli 

do danego układu planetarnego wpadnie asteroida lub planetoida itp. 

77

- Zachowanie zwierząt. Zwierzęta kontrolują pozycję innych osobników i obiektów wokół 

siebie i na tej podstawie decydują o swoim zachowaniu. Zachowanie to może dotyczyć 

zdobywania jedzenia, wypatrywania drapieżników, utrzymywania się w zwartych stadach 

gdzie nie może dochodzić do wzajemnych kolizji. 

- Tego typu symulacje mogą też służyć do kierowania przepływem ruchu w przypadku 

projektowania wyjść ewakuacyjnych z budynków, projektowania systemów ulicznych w 

celu minimalizowania zatorów, szkolenia kierowców w technikach unikania kolizji na 

drodze itp. 

78

Kinetyczny model gazu doskonałego. 

Inspiracją do powstania tego modelu stał się standardowy skrypt VPython'a, który można znaleźć w 

katalogu C:\Program Files\Python23\Lib\site-packages\visual\demos\gas.py 

Stanowi on bardziej złożoną (pod względem ilości parametrów fizycznych) i udoskonaloną (pod 

względem detekcji i odpowiedzi zderzenia) wersję programu symulującego zachowanie się gazu 

doskonałego. 

1. Wprowadzenie 

Poprzednie modele gazu były czysto mechaniczne. Jednakże przy ich pomocy można było 

zobaczyć, że prędkości poszczególnych atomów w gazie nie są jednakowe. Kolejny model 

jaki zostanie przedstawiony będzie uwzględniał więcej fizycznych parametrów takich jak 

masa atomów, temperatura, prędkości poszczególnych atomów będą zbliżone do 

rzeczywistych. Jako przykład rozważymy zbiornik zawierający hel albo jakiś inny gaz 

szlachetny, którego cząsteczki są pojedynczymi atomami bez żadnych ruchów 

wewnątrzcząsteczkowych. Będą to mogły być również pary jakiegoś gazu na przykład rtęci 

przy założeniu, że temperatura będzie dostatecznie wysoka aby dany pierwiastek mógł 

występować w stanie lotnym. Jeśli cząsteczka jest złożona, to mogą w niej występować 

ruchy wewnętrzne, na przykład drgania lub rotacje. W rozpatrywanym modelu nie będą 

uwzględniane takie przypadki a energia kinetyczna ruchu środka masy atomu będzie 

stanowić jego całkowitą energię. Dla gazu jednoatomowego energia całkowita jest więc jego 

energią kinetyczną. Porównany zostanie też rozkład prędkości cząsteczek w symulowanym 

modelu z rozkładem Maxwell'a. 

2. Zainicjowanie obiektów i nadanie im parametrów 

Jak zwykle zaczynamy 9 od umieszczenia na samym początku programu procedur 

importujących niezbędne moduły, tworzących okno 3D oraz zbiornik, w którym umieścimy 

gaz (plik 03_gas_adaptacja10.py) 


from visual.graph import * 

from random import random 

from random import uniform 

#--------------------------------------- 

# wykonanie zbiornika 

#--------------------------------------- 

# parametry mogace podlegac zmianom 

d_sc = 0.05 

# grubosc scianki 

half_L = 4.0 

# polowa dlugosci zbiornika 

d_b = half_L - d_sc 

# dlugosc scianek bocznych 

d_g = half_L + d_sc 

# dlugosc scianek gornej i dolnej 

kolor_zbiornika=(0.0,0.7,0.7) 

kolor_zbiornika2=(1.0,0.6,0.2) 

#---------------------------------------- 

scianka_prawa = box (pos=vector( half_L, half_L/2., 

9 Uwaga: niektóre części skryptu zostały pominięte. Kompletny działający kod znajduje się na dołączonej płycie CD 

79

half_L/2.),length=d_sc, height=d_b, width=d_g,color = kolor_zbiornika) 

scianka_lewa = box (pos=vector(0, half_L/2., half_L/2.),length=d_sc, 

height=d_b,width=d_g,color = kolor_zbiornika) 

scianka_dolna = box (pos=vector(half_L/2., 0, half_L/2.),length=d_g, 

height=d_sc, width=d_g,color = kolor_zbiornika2) 

scianka_gorna = box (pos=vector(half_L/2., half_L, half_L/2.),length=d_g, 

height=d_sc, width=d_g,color = kolor_zbiornika2) 

scianka_tylna = box(pos=vector(half_L/2., half_L/2., 0),length=d_b, 

height=d_b, width=d_sc,color = kolor_zbiornika2) 

Następnie przystępujemy do zdefiniowania parametrów atomów i niezbędnych stałych 

fizycznych 

# parametry mogace podlegac zmianom 

Nb_of_atoms = 30 

# zmien aby otrzymac wiecej lub mniej atomow 

Masa_atom = 4E-3/6E23 # masa atomu helu 

R_atom = 0.3 

# widoczny rozmiar atomu 

k = 1.4E-23 

# stala Boltzmana 

T = 300.0 

# [K] temperatura gazu 

max_speed = 6000.0 

# przewidywalna maksymalna predkosc atomow 

dt = 1E-5 

# krok czasowy symulacji 

Kolor_atomu = (0.0,0.4,1.0) 

maxpos=half_L-0.5*d_sc-R_atom #maksymalna pozycja atomu (przy losowaniu) 

Do przechowywania danych będziemy potrzebować następujące tablice 

#puste listy do przechowywania obiektów i zmiennych 

Atoms = [] #obiekty - atomy 

poslist = [] #lista położeń 

plist = [] #lista pędów atomów 

mlist = [] #lista mas 

rlist = [] #lista promieni 

#inicjacja atomow i nadanie im atrybutow 

for i in range(Nb_of_atoms): 

#global Masa_atom,R_atom 

ppp=maxpos*vector(uniform(0.5*d_sc+R_atom,1),uniform(0.5*d_sc+R_atom,1 

),uniform(0.5*d_sc+R_atom,1)) 

Atoms = Atoms+[sphere(pos=(ppp), radius=R_atom, color=Kolor_atomu)] 

#srednia energia kinetyczna p**2/(2mass) = (3/2)kT 

#zatem ped bedzie dany wzorem 

ped_sredni = sqrt(2.*Masa_atom*1.5*k*T) # average kinetic energy 

p**2/(2mass) = (3/2)kT 

theta = pi*random() 

phi = 2*pi*random() 

#wsp sferyczne 

px = ped_sredni*sin(theta)*cos(phi) 

py = ped_sredni*sin(theta)*sin(phi) 

pz = ped_sredni*cos(theta) 


plist.append((px,py,pz)) 

mlist.append(Masa_atom) 

rlist.append(R_atom) 

# by byly mozliwe operacje na tablicach dokonujemy ich skopiowania 

80

pos = array(poslist) 

p = array(plist) 

m = array(mlist) 

#zamiana z wiersza (n-atomow) na kolumne o tylu wierszach 

m.shape = (Nb_of_atoms,1) # Numeric Python: (1 by Natoms) vs. (Natoms by 

1) 

radius = array(rlist) 

t = 0.0 

pos = pos+(p/m)*(dt/2.) 

# wyzerowanie czasu 

# initial half-step 

3. Wizualizacja danych w postaci histogramu 

Prawo rozkładu prędkości atomów w gazie dotyczy najbardziej prawdopodobnego rozkładu 

prędkości dużej liczby atomów gazu [8]. Dla próbki zawierającej N cząsteczek gazu 

3 

m 

przyjmuje ono postać: N v=4 N 

2 k T 

2 

2 v 2 e −mV 2kT 

gdzie N v jest liczbą 

cząsteczek w próbce posiadających prędkości zawarte w przedziale v i vdv . T - 

temperatura bezwzględna, k - stała Boltzmanna. 

Aby zobaczyć jak kształtuje się rozkład prędkości cząsteczek w prezentowanym modelu 

posłużymy się funkcją ghistogram(), która częściowo automatyzuje proces tworzenia 

histogramu. Prędkości atomów przed wizualizacją muszą być sortowane, oraz musi być 

znana liczba atomów mieszcząca się w danym przedziale prędkości, przy czym obie 

czynności należy wykonywać w każdym kroku czasowym. Dodatkowo chcemy aby dane 

uzyskane w jednym kroku czasowym były dodawane do danych z kolejnego kroku, a wynik 

wyświetlany był w postaci średniej tych wartości. Wszystkie omówione czynności funkcja 

ghistogram() może wykonywać automatycznie. W przypadku krzywej teoretycznej musimy 

jednak pamiętać, że wartości umieszczane na osi igreków należy dodatkowo pomnożyć 

przez wartość przedziału prędkości czyli zmienną deltav. Uzyskamy w ten sposób na osi 

igreków liczbę atomów zawartych w danym przedziale prędkości. Jest to jedyna różnica 

o której musimy pamiętać gdy będziemy chcieli obliczyć całkę N =∫ 

0 

∞ 

N vdv 

poznać jaka jest całkowita liczba atomów, wtedy wartości deltav nie należy brać pod uwagę. 

# histogram 

czyli 

#przedzialy predkosci co deltav 

deltav = 100. 

vdist = gdisplay(x=0, y=frm, ymax = Nb_of_atoms*deltav/1000., 

width=800, height=700-frm, xtitle='v', 

ytitle='dN',foreground=pierwszoplanowy, background=drugoplanowy) 

theory = gcurve(color=color.red) 

observation = ghistogram(bins=arange(0.,max_speed,deltav), 

accumulate=1, average=1, 

color=Kolor_atomu) 

dv = 10. 

for v in arange(0.,max_speed+1+dv,dv): # theoretical prediction 

theory.plot(pos=(v,(deltav)*Nb_of_atoms*4.*pi*((Masa_atom/(2.*pi*k*T)) 

**1.5) 

*exp((-0.5*Masa_atom*v**2)/(k*T))*v**2)) 

81

4. Główna pętla. 

Zajmijmy się teraz konkretami czyli pętlą odpowiedzialną za przesuwanie atomów, detekcję 

wzajemnych zderzeń między atomami i ze ściankami naczynia. 

Pętlę rozpoczynamy od opcjonalnej funkcji ograniczającej szybkość wykonywania 

algorytmu. Umieszczona tu została w linii komentarza ponieważ obecny algorytm jest 

o wiele bardziej złożony od poprzednich, lecz w przypadku gdy będziemy symulować 

zachowanie się niewielkiej liczby atomów musimy pamiętać o tym, iż może okazać się 

niezbędny do ograniczenia tempa. Kolejna linia kodu odpowiedzialna jest za obliczenie 

wartości prędkości każdego z atomów, przekształcenie tych danych na listę i przekazanie 

tych informacji do histogramu, gdzie są on sortowane uśredniane a następnie wyświetlane. 

Następna linia aktualizuje tablicę przechowującą dane z położeniami atomów. 

while 1: 

#rate(30) 

observation.plot(data=mag(p/m)) 

# Uaktualnienie tablicy zawierajacej polozenia 

pos += (p/m)*dt 

#czyli x = x_0 + v*t 

W każdym kroku pętli będziemy sprawdzać czy nie doszło do kolizji pomiędzy atomami. 

W tym celu wyznaczamy wzajemne odległości między atomami najpierw w formie 

wektorów, a później wyliczamy ich długość (wielkość skalarną). 

r = pos-pos[:,NewAxis] # wyznaczenie odległości pomiędzy atomami jako 

wektorów 

rmag = sqrt(add.reduce(r*r,-1)) # przekształcenie tych odległości na 

skalary 

hit = less_equal(rmag,radius+radius[:,NewAxis])-identity(Nb_of_atoms) 

Jeżeli odległość między dwoma atomami będzie mniejsza niż suma dwóch promieni to 

znaczy, że nastąpiła penetracja między atomami i w zmiennej hit pojawią się niezerowe 

wartości na przykład: 

#przykładowe dane pochodzące ze zderzenia atomów w gazie składającym się z 

3 atomów 

R_atom=0.3 #promień atomu 

rmag #odległości (skalarnie) pomiędzy atomami 

[[ 0. 1.49881131 1.72266461] 

[ 1.49881131 0. 0.59806834] 

[ 1.72266461 0.59806834 0. ]] 

#(na czerwono zostały oznaczone odległości mniejsze niż 2r) 

hit= 

[[0 0 0] 

[0 0 1] 

[0 1 0]] 

Będzie to oznaczało, że zadziała pierwsza część funkcji zderzenie(). Nim omówiona 

zostanie ta funkcja musimy otrzymać dostęp do parametrów kolidujących atomów a tym 

samym dowiedzieć się dokładnie, między którymi atomami doszło do zderzenia. W tym 

celu przystępujemy do przekształcenia tablicy hit na listę w następujący sposób 

82

hitlist = sort(nonzero(hit.flat)).tolist() 

atom o numerze „i” kolidujący z atomem o numerze „j” będzie umieszczony w tej liście 

w postaci liczby wynoszącej i⋅Nb_of_atoms j na przykład: 

hitlist=[5, 7] 

przy czym druga liczba to j⋅Nb_of_atomsi (ponieważ tablica rmag zawiera odległości 

każdego atomu z każdym – jest symetryczna, więc tablica hit również jest symetryczna a to 

powoduje, że hitlist zawierać będzie parę takich liczb). 

Nadeszła teraz pora na omówienie działania funkcji zderzenie(), która wprowadzi nieco 

porządku. Pierwsza jej część operuje na zmiennej o nazwie bounce, którą w naszym 

przypadku jest tablica hitlist. Zatem na każdym elemencie z tablicy wykonywane jest 

dzielenie z resztą elementu tablicy przez liczbę atomów, w wyniku czego otrzymujemy parę 

liczb „i” oraz „j”. Będą one stanowiły wskaźniki odpowiednio wiersza i kolumny w tablicy 

hit ( liczone od zera). 

def zderzenie(bounce): 

"""funkcja odpowiedzialna za 

obsługę 

zderzeń miedzy atomami i atomów 

ze ściankami naczynia""" 

global p 

for ij in bounce: 

#rozszyfrowanie miedzy 

którą para atomów doszło do 

zderzenia 

i, j = 

divmod(ij,Nb_of_atoms) # 

rozszyfrowanie dla atomów parami 

Jeżeli zmienna hitlist zawiera na przykład 

elementy [5, 7] to w wyniku pierwszego 

dzielenia otrzymamy parę liczb i=1 

oraz j=2 co daje nam odpowiedź na 

pytanie, między którą parą atomów doszło 

do kolizji. Kolejna liczba z listy hitlist nie 

będzie już zatem potrzebna więc po prostu 

jest z niej usuwana 

hitlist.remove(j*Nb_of_atoms+i) 

# usuniecie symetrycznej pary j, i 

z listy 

Znalezienie pary atomów kolidujących ze 

sobą nie oznacza zakończenia procesu 

detekcji zderzenia. Gdybyśmy teraz przeszli 

do odpowiedzi zderzenia, popełnilibyśmy 

błąd. Zgodnie ze wcześniej poczynionymi 

założeniami atomy traktujemy jak bryły 

sztywne, co wyklucza możliwość 

wzajemnego przenikania się tych obiektów. 

Rysunek 53: Schemat działania algorytmu detekcji 

Dlatego aby móc przejść do odpowiedzi 

zderzenia. 

83

zderzenia musimy znaleźć położenia atomów w chwili gdy stykały się ze sobą, ponieważ 

wtedy właśnie powinna nastąpić detekcja zderzenia. 

Na rysunku przedstawiono przykładowe wzajemne położenie atomów w chwili t=0 (rys A) 

oraz w następnym kroku czasowym 10 t=dt (rys B) to jest chwili, w której następuje detekcja 

zderzenia. Skorygowanie położeń i odpowiedź zderzenia prześledźmy na przykładzie. 

Prędkość pierwszego atomu wynosi v i 

=5.0,0 .0 ,0 .0 a drugiego v j 

= 0.0,0 .0 ,0 .0 . 

Zgodzie z rysunkiem (B) przyjmujemy, że w chwili t=dt atom pierwszy znajdował się w 

punkcie O i ,t =dt 

=−1.8,0 .0 ,0.0 a drugi w początku układu współrzędnych 

O j ,t =dt 

=0.0 ,0 .0 ,0.0 . Aby dowiedzieć się jakie były położenia atomów w chwili 

zetknięcia się ich powierzchni musimy obliczyć czas trwania penetracji obiektów. Znamy 

zarówno położenie, prędkości a promienie są równe i wynoszą na przykład r 1 

=r 2 

=1 . 

Zgodnie z rysunkiem B 

x=R−K gdzie R=r 1 

r 2 , K =∣O i ,t =dt 

− O j ,t= dt 

∣ 

więc czas penetracji deltat 

deltat= R− K gdzie Dvel=∣v 

Dvel 

i 

− v j 

∣ 

w naszym przykładzie deltat=0.04 

położenia atomów muszą być zatem skorygowane 

O i ,t =dt 

= O i , t=dt 

−v i 

⋅deltat 

O j ,t =dt 

= O j ,t= dt 

−v j 

⋅deltat 

i dla chwili zetknięcia wynosić będą one 

O i ,t =dt 

=2.0 ,0 .0 ,0 .0 

O j ,t =dt 

=0.0 ,0 .0 ,0.0 

część algorytmu wykonująca poprawienie położeń atomów wygląda następująco: 

mi = m[i,0] 

mj = m[j,0] 

R = Atoms[i].radius+Atoms[j].radius 

K = mag(pos[i]-pos[j]) 

Dvel = mag((p[i]/mi)-(p[j]/mj)) 

deltat=(R-K)/Dvel 

#skorygowanie położeń do pozycji zetknięcia czyli cofnięcie o czas deltat 

pos[i] = pos[i]-(p[i]/mi)*deltat 

pos[j] = pos[j]-(p[j]/mj)*deltat 

Można powiedzieć, że „cofnęliśmy się w czasie” o deltat czyli do momentu w którym 

obiekty stykają się ze sobą (rys C). Odpowiedź zderzenia to problem fizyczny ruchu 

atomów po zderzeniu. W odpowiedzi zderzenia będziemy korzystali z zasady zachowania 

pędu. Jak założyliśmy wcześniej zderzenia są doskonale sprężyste, a całkowity pęd 

zderzających się atomów nie ulega zmianie. 

Zdecydowanie prostsze w obliczeniach jest rozpatrywanie zderzenia dwóch kul w układzie 

środka masy (CM Centre of Mass). Jeżeli oznaczymy przez v CM i prędkość pierwszego 

atomu w układzie środka masy, v śr M prędkość środka masy, to prędkość atomu 

w układzie LAB v i możemy napisać jako 

v i 

=v CM i 

v śr M 

Należy jeszcze znaleźć pędy poszczególnych atomów w układzie CM. 

p tot 

=p i 

p j 

M =m i 

m j 

10 Nie należy mylić dt z różniczką, ponieważ w tym przypadku dt oznacza krok czasowy (dyskretny przyrost czasu w 

każdym kolejnym kroku pętli). Jest wartością dobraną empirycznie i dla tej symulacji wynosi 1E-5s 

84

v CM i 

M v śr M 

M =v i 

M 

m i 

m i 

v CM i 

M v śr M 

M = m i 

m i 

v i 

M 

p CM i 

M 

m i 

p tot 

=p i 

M 

m i 

p CM i 

p tot 

m i 

M =p i 

m 

p CM i 

=p i 

−p 

i 

tot 

otrzymaliśmy w ten sposób pęd atomu pierwszego w układzie środka 

M 

masy. Postępując analogicznie w przypadku atomu drugiego v j 

=v CM j 

v śr M otrzymamy 

m 

p CM j 

= p j 

−p 

j 

tot 

M 

Są to równania pozwalające transformować pędy poszczególnych atomów z układu LAB do 

układu środka masy. 

Kolejnym krokiem jest wyznaczenie pędów atomów po zderzeniu. Linię akcji na której 

dochodzi do zderzenia oznaczamy przez r 

rel a pędy po zderzeniu będą wyrażały się 

w sposób następujący: 

p CM i 

=p CM i 

−2 p CM i 

⋅r 

rel r 

rel 

p CM j 

= p CM j 

−2p CM j 

⋅r rel r 

rel 

gdzie p CM i 

⋅r 

rel , p CM j 

⋅r 

rel to wartości pędu w układzie CM na linii akcji, więc 

w efekcie otrzymamy pędy (jako wielkości wektorowe) po zderzeniu. Następnie powracamy 

do układu LAB 

p i 

=p CM i 

p tot 

m i 

M 

p j 

= p CM j 

p tot 

m j 

M 

Została jeszcze kwestia „cofniętego czasu”. Atomy po zderzeniu kontynuują ruch z nowymi 

prędkościami, więc uwzględniając ten fakt musimy wyznaczyć nowe przemieszczenie 

w czasie deltat (rys D). 

pos i 

= pos i 

p i 

deltat 

m i 

pos j 

= pos j 

p j 

deltat 

m j 

część skryptu realizująca wyżej opisane działania wygląda następująco: 

ptot = p[i]+p[j] #suma geometryczna 

mtot = mi+mj 

# przejscie do ukladu CM 

pcmi = p[i]-ptot*mi/mtot 

pcmj = p[j]-ptot*mj/mtot 

# jednostkowy wektor linii akcji 

rrel = norm(pos[j]-pos[i]) 

# zderzenie w ukladzie CM 

pcmi = pcmi-2*dot(pcmi,rrel)*rrel 

pcmj = pcmj-2*dot(pcmj,rrel)*rrel 

# transformacja do ukladu LAB 

p[i] = pcmi+ptot*mi/mtot 

p[j] = pcmj+ptot*mj/mtot 

# kontynuacja ruchu w czasie deltat z nowymi prędkościami 

pos[i] = pos[i]+(p[i]/mi)*deltat 

85

pos[j] = pos[j]+(p[j]/mj)*deltat 

To jeszcze jednak nie wszystko. Druga część funkcji zderzenie() jest odpowiedzialna za 

detekcję i obsługę kolizji atomów ze ściankami naczynia. Najprościej rzecz ujmując jej 

działanie opiera się na prawie odbicia, lub jeżeli sprawę opisujemy w sposób wektorowy, na 

zmianie znaku odpowiedniej składowej pędu atomu w przypadku przekroczenia dozwolonej 

pozycji jaką stanowią ścianki pojemnika. Jest to realizowane w sposób następujący. Tak jak 

w poprzednich przypadkach dotyczących detekcji zderzenia tu również mamy dwa warunki 

sprawdzające pozycję atomów. Pierwszy z nich sprawdza czy pozycje poszczególnych 

atomów nie są mniejsze niż promień atomu. Wynika stąd specyficzne usytuowanie 

zbiornika, wymagające aby jeden z wierzchołków zbiornika znajdował się w początku 

układu współrzędnych. Jeżeli się tak zdarzy, że składowa położenia któregokolwiek 

z atomów będzie będzie mniejsza niż promień atomu to w tablicy outside pojawi (lub 

pojawią się) się niezerowa wartość. Tą wartością będzie jeden, ale niesie ona ze sobą jeszcze 

jedną istotną informację a mianowicie wskazuje konkretnie, która składowa ma ulec zmianie 

na przeciwną, gdyż wiersze tej tablicy oznaczają atomy, natomiast kolumny oznaczają 

składowe odpowiednio x, y i z. Zatem zmienna p1 będzie zawierała składową (lub 

składowe) pędu, której należy zmienić znak na przeciwny. Drugi warunek sprawdza czy 

czy pozycje poszczególnych atomów nie są większe niż zmienna maxpos i działa zupełnie 

analogicznie jak warunek pierwszy. Ostatnim zadaniem funkcji zderzenie() jest aktualizacja 

położeń wszystkich atomów. 

#część odpowiedzialna za obsługę 

#zderzeń atomów ze ściankami naczynia 

outside = less_equal(pos,R_atom) 

p1 = p*outside 

p = p-p1+abs(p1) # (odwrócenie składowej pędu do środka zbiornika) 

outside = greater_equal(pos,maxpos) 

p1 = p*outside 

p = p-p1-abs(p1) # (odwrócenie składowej pędu do środka zbiornika) 

# Uaktualnienie pozycji wyswietlanych obiektow 

for i in range(Nb_of_atoms): 

Atoms[i].pos = pos[i] 

return 

86

Rysunek 54: Rozkłady prędkości Maxwell'a dla 100 atomów helu w trzech różnych temperaturach. 

87

W przypadku krzywej teoretycznej liczba atomów o prędkościach leżących w określonym 

przedziale jest równa polu powierzchni pod odpowiednim odcinkiem krzywej. 

m 

v- prędkość w 

s 

liczbacząsteczek 

dN – liczba atomów zawartych w jednostkowych przedziałach prędkości w m 

s 

Możemy również uzyskać informacje o rozkładzie prędkości w danym kroku czasowym. 

Wystarczy tylko zmodyfikować sposób rysowania wykresu usuwając zmienne 

odpowiedzialne za sumowanie i uśrednianie danych. Dane uzyskane w ten sposób są 

widoczne na ilustracji poniżej. Ilość atomów mieszcząca się w danym przedziale prędkości 

jest wówczas liczbą całkowitą. (plik 03_gas_adaptacja10_verb.py) 

observation = ghistogram(bins=arange(0.,max_speed,deltav), 

#accumulate=1, average=1, 

color=Kolor_atomu) 

Rysunek 55: Rozkład prędkości atomów w jednym z kolejnych kroków czasowych. 

88

9. Zakończenie 

Eksperyment komputerowy nie jest procesem jednorazowym. Wymaga on zazwyczaj wielu 

prób i testów na etapie budowy zarówno modelu fizycznego jak i algorytmu numerycznego. 

Zazwyczaj pierwsze poprawne wyniki ukazują niedoskonałości opisu modelu matematycznofizycznego 

i modeli przy pomocy których ilustrujemy dane zjawisko. Rozbudowywanie 

i poprawianie modelu należy przeprowadzać aż do uzyskania zadowalających wyników. W takich 

przypadkach ważne jest, aby kody programów były przystosowane na wprowadzanie zmian. Szybki 

postęp wiedzy powoduje, że zmiany takie są praktycznie nieuchronne, a doskonalenie modelu 

i kodu staje się procesem ciągłym. 

Również fizyka komputerowa nie daje także jednoznacznych odpowiedzi które algorytmy 

będą najlepsze do rozwiązania danego problemu. Zazwyczaj o wyborze algorytmu decyduje 

doświadczenie i intuicja badacza, który musi niejednokrotnie porównywać informacje 

zamieszczone w pracach badawczych z wynikami symulacji, gdyż całościowe rozwiązanie danego 

problemu zależy od wielu kwestii fizycznych, matematycznych i programowych. Należy także 

podkreślić, że istnieje jeszcze wiele technik, mniej lub bardziej wydajnych, przy pomocy których 

można przedstawić opisane zjawiska. 

Zdaję sobie sprawę, że przedstawione zjawiska i metody nie wyczerpują w żadnym 

wypadku tematu. Sama praca stanowi raczej wprowadzenie do tego typu zagadnień i mam nadzieję, 

że przedstawione rezultaty zachęcą Czytelnika do samodzielnego studiowania podobnych 

zagadnień fizycznych. 

89

10. Bibliografia 

1. Chris Fehily, Po prostu Python, Wydawnictwo Helion, Gliwice 2002 

2. D. Ascher, P. F. Dubois, K. Hinsen, J. Hugunin, T. Oliphant , Numerical Python , Lawrence 

Livermore National Laboratory, Livermore 2001 (http://www.scipy.org/NumPy_Tutorial) 

3. D. M. Bourg, Fizyka dla programistów gier, Wydawnictwo Helion, Gliwice 2003 

4. Guido van Rossum, Fred L. Drake, Podręcznik programisty Pythona, 

(http://docs.python.org/ref/ref.html) 

5. Pod red. K. Jacha, Komputerowe modelowanie dynamicznych oddziaływań ciał metodą 

punktów swobodnych, Wydawnictwo PWN, Warszawa 2001 

6. K. Stefański, Wstęp do mechaniki klasycznej, Wydawnictwo PWN, Warszawa 1999 

7. R. P. Feynman, R. B. Leighton, M. Sands, Feynmana wykłady z fizyki, tom 1.1 oraz 1.2, 

Wydawnictwo PWN, Warszawa 2004 

8. R. Resnic, D. Halliday, Fizyka, tom 1, Wydawnictwo PWN, Warszawa 2001 

9. W. Rubinowicz, W. Królikowski, Mechanika teoretyczna, Wydawnictwo PWN, Warszawa 

1980 

10. E.Kalinowska, K.Kalinowski, Metody numeryczne, Wydawnictwo Pracowni Komputerowej 

Jacka Skalmierskiego, Bielsko-Biała 2003 

11. J. Krupka, Z. Morawski, J. Opalski, Wstęp do metod numerycznych dla studentów 

elektroniki i technik informacyjnych, Oficyna Wydawnicza Politechniki Warszawskiej 

,Warszawa 1999 

12. J. R. Taylor , Wstęp do analizy błędu pomiarowego, Wydawnictwo PWN, Warszawa 1999 

Witryny internetowe: 

A) Harvard University - Natural Science, Lecture Demonstrations - Center of Percussion, 

http://www.fas.harvard.edu/~scdiroff/lds/NewtonianMechanics/CenterofPercussion/CenterofPercussion.html 

B) Sally Lloyd i Stephen Roberts, Using VPython to Simulate a Ball Bouncing in a Box, 

http://www.maths.anu.edu.au/comptlsci/Tutorial-Gas/tute-bounce.html 

C) Sally Lloyd i Stephen Roberts, Using VPython to Simulate a Gas, 

http://www.maths.anu.edu.au/comptlsci/Tutorial-Gas/tute-gas.html 

D) L. Urbano and J. Houghton, An Interactive Computer Model for Coriolis Demonstrations, 

Journal of Geoscience Education 2006, 

http://lurbano-5.memphis.edu/GeoMod/index.php/Main_Page 

E) M. Matyka, Symulacje komputrowe w fizyce, 

http://panoramix.ift.uni.wroc.pl/~maq/pl/ 

F) R. Salgado, VPython applications for Teaching Physics, 

http://physics.syr.edu/~salgado/software/vpython/ 

G) R. Chabay, D. Scherer, and B. Sherwood The Visual Module of VPython, 

http://vpython.org/webdoc/visual/index.html 

90

Symulacje komputerowe zjawisk fizycznych z zakresu mechaniki

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?