Program Maple - modelowanie i symulacja zjawisk

Instytut Sterowania i Systemów Informatycznych
Uniwersytet Zielonogórski
Metody matematyczne w informatyce – laboratorium
Program Maple - modelowanie i symulacja zjawisk
Program laboratorium obejmuje następujące zagadnienia:
• Animacja ruchu prostego wahadła matematycznego:
Po pewnych uproszczeniach (np. założenie jednostkowej długości) oraz dla małych kątów θ ruch (wychylenie)
wahadła matematycznego można opisać równaniem różniczkowym zwyczajnym:
d2 θ
+θ =0
dt2
gdzie θ oznacza kąt wychylenia wahadła (θ jest zależne od czasu).
W celu wyznaczenia funkcji opisującej ruch wahadła rozwiązujemy równanie różniczkowe zwyczajne ruchu
wahadła:
[> eqns:=diff(theta(t),t$2)+theta(t)=0;
[> dsolve(eqns,theta(t));
Jak zinterpretować rozwiązanie? - otrzymaliśmy rozwiązanie ogólne - rodzinę funkcji ( C1 oraz C2 oznaczają
dowolne stałe). Równanie trzeba uzupełnić odpowiednimi warunkami początkowymi (wychylenie początkowe θ(0) oraz początkowa prędkość kątowa dθ
dt w chwili t = 0):
[> ics:=theta(0)=a,D(theta)(0)=b;
i ponownie rozwiązać:
[> dsolve({eqns,ics},theta(t));
Przy założeniu zerowego wychylenia początkowego oraz jednostkowej początkowej prędkości kątowej mamy:
[> ics:=theta(0)=0,D(theta)(0)=1;
[> dsolve({eqns,ics},theta(t));
Zwizualizujemy następnie ruch wahadła wg otrzymanego ostatecznie rozwiązania we współrzędnych biegunowych wraz z animacją zmiany wartości parametru:
[> T:=100:
[>
 dt:=2*Pi/T:
> for i to T do

u[i]:=evalf(sin(i*dt)):
v[i]:=evalf(cos(i*dt)):od:
> for i to T do
p[1,i]:=plot([[u[i],0],[0,v[i]],[u[i],v[i]]],style=point,symbol=circle,color=blue):od:

> for i to T do

p[0,i]:=plot([s,-Pi/2+sin(i*dt),s=0..1],numpoints=2,coords=polar,color=red):


p[2,i]:=plot([[cos(-Pi/2+sin(i*dt)),sin(-Pi/2+sin(i*dt))]],style=point,symbol=circle,
color=red,thickness=2):od:
> for i to T do
uu[i]:=plots[display]([p[0,i],p[1,i],p[2,i]]):od:
[> plots[display]([seq(uu[i],i=1..T)],insequence=true);
1
• Interferencja:
Jeżeli wrzucisz do stawu dwa kamienie, na powierzchni wody zaobserwujesz wzór interferencyjny, powstający
w wyniku nakładania się dwóch rozchodzących się koliście fal. Ten sam efekt zaobserwujemy, gdy nakładać
się będą na siebie dwie fale świetlne. Przy pomocy programu Maple zaobserwujemy interferencję (nakładanie
się) dwóch identycznych fal sinusoidalnych przy zmiennym przesunięciu fazowym.
Jeśli
obie fale znajdują się w takiej samej fazie, interferencja prowadzi do wzmocnienia fali:

> restart:

with(plots):
with(plottools):

> a1:=plot(1.01*sin(t),t=0..4*Pi,y=-2..2,color=blue):

a2:=plot(sin(t),t=0..4*Pi,y=-2..2,color=red):
a3:=plot(sin(t) + sin(t),t=0..4*Pi,y=-2..2,color=magenta):
[> display({a2,a1,a3},title = ”sin(t) + sin(t)”,axes=none);
W
 przypadku, gdy fale są w fazie przeciwnej, interferencja prowadzi do wygaszenia fali:
> b1:=plot(sin(t), t=0..4*Pi, y=-1..1, color=blue):

b2:=plot(sin(t + Pi), t=0..4*Pi, y=-1..1, color=red):
b3:=plot(sin(t) + sin(t + Pi), t=0..4*Pi, y=-1..1, color=magenta):
[> display({b1, b2, b3}, title = ”sin(t) + sin(t + Pi)”, axes=none);
Następnie wykonamy animację, pokazującą efekt nałożenia się dwóch fal, gdy kąt przesunięcia fazowego
zmienia się od 0 do 2Π:

> c1 := plot(sin(t), t=0..4*Pi, y=-2..2, color=blue):

numFrames := 80:


for
i from 1 to numFrames do


c2[i]
:= plot(sin(t - (i - 1)*2*Pi/numFrames), t=0..4*Pi, y=-2..2, color=red):


c3[i] := plot(sin(t) + sin(t - (i - 1)*2*Pi/numFrames), t=0..4*Pi, y=-2..2, color=magenta):od:


for i from 1 to numFrames do


disp||i
:= display(c2[i], c3[i]):


od:
waveAni := display(disp||(1..numFrames), insequence=true):
[> display({waveAni, c1},axes=none);
UWAGA - używając programu Maple w wersji 5.1 należy operator konkatenacji łańcuchów ”||” zamienić na
”.”
• Efekt Dopplera:
Przypuśćmy, że stoisz na ulicy w chwili, gdy mija cię samochód jadący z włączonym na stałe głośnikiem
emitującym dźwięk o częstotliwości 440Hz. W trakcie zbliżania się samochodu w twoim kierunku usłyszysz
dźwięk o częstotliwości nieco większej niż 440 Hz, a gdy samochód minie cię i zacznie się oddalać, częstotliwość
dźwięku słyszanego przez ciebie spadnie poniżej 440 Hz. To znane zjawisko fizyczne, zwane efektem Dopplera
(przesunięcie częstotliwości i długości fali odbieranej) jest spowodowane przez ruch źródła fali (np. samochód)
względem medium w którym rozchodzi się fala (np. atmosfera). Jeżeli źródło fali zbliża się do odbiorcy odbierana częstotliwość będzie wyższa niż emitowana przez źródło i vice versa. Używając programu Maple
zademonstrujemy zachowanie rozchodzącej się fali w przypadku, gdy:
1. Źródło fali nie porusza się,
2. Źródło porusza się ze stałą prędkością, mniejszą niż prędkość rozchodzenia się fali,
3. Źródło porusza się z taką samą prędkością, co rozchodząca się fala,
4. Źródło porusza się ze stałą prędkością, większą niż prędkość rozchodzenia się fali,
5. Źródło przyspiesza, wyprzedzając rozchodzącą się falę.
2
W
 nowym arkuszu programu Maple ładujemy potrzebne do animacji pakiety:
> restart:

with(plots):
with(plottools):
Wprowadzamy
procedurę wyliczającą klatki animacji:

> wave := proc(n,initSpeed,finalSpeed)

local i, li, j, circles, se, source, slope:


slope := (finalSpeed - initSpeed) / n:


for i from 0 to n*4 do


li := NULL:


for j from 1 to n do


if i > (j-1)*4 then


circles[j][i] := circle([initSpeed * (j-1) + 0.5 * slope * (j-1)ˆ2, 0], (i-(j-1)*4) / 4):


li := circles[j][i], li:



fi:


od:


source:=point([initSpeed * i/4 + 0.5 * slope * (i/4)ˆ2, 0], color=blue, symbol=circle, symbolsize=12):


animation||i := display([li, source]):


od:


se := animation||(0..n*4):
end:
UWAGA - używając programu Maple w wersji 5.1 należy operator konkatenacji łańcuchów ”||” zamienić na
”.”
Parametry wejściowe procedury to: n - ilość okresów fali wyemitowanej ze źródła, initSpeed - względna
prędkość początkowa źródła fali (np. wartość 0.5 oznacza, że źródło fali porusza się 2 razy wolniej, niż sama
fala), finalSpeed - względna prędkość końcowa źródła fali.
Wywołanie procedury i animacja wyników:
1. Źródło nieruchome.
[> wave1 := wave(10,0,0):
[> display(wave1,insequence=true,scaling=constrained, axes=none);
Okręgi można interpretować jako szczyty rozchodzącej się fali dźwiękowej, zatem odległość pomiędzy
okręgami będzie równa długości fali. Do odbiorcy dochodzi fala o takiej samej częstotliwości, co fala
emitowana przez źródło.
2. Źródło porusza się ze stałą prędkością, mniejszą niż prędkość rozchodzenia się fali.
[> wave2 := wave(10,0.5,0.5):
[> display(wave2,insequence=true,scaling=constrained, axes=none);
Tym razem źródło fali porusza się w prawo ze stałą prędkością, równą połowie prędkości samej fali.
Jak widać długość fali obserwowanej przez odbiorcę usytuowanego z prawej strony jest mniejsza niż
w poprzednim przypadku. Ponieważ długość fali i częstotliwość są związane zależnością odwrotnie
proporcjonalną - odpowiada to wzrostowi częstotliwości fali z prawej strony.
3. Źródło porusza się z taką samą prędkością, co emitowana fala.
[> wave3 := wave(10,1,1):
[> display(wave3,insequence=true,scaling=constrained, axes=none);
Jeśli źródło byłoby interpretowane jako poruszający się samolot, mamy do czynienia z sytuacją, gdy samolot porusza się dokładnie z prędkością dźwięku (Mach 1). Obserwator znajdujący się z prawej strony
nie usłyszy żadnego dźwięku do chwili, gdy samolot nie znajdzie się dokładnie w punkcie obserwacji.
Dźwięk zostanie usłyszany jako huk (tzw. „grom dźwiękowy”) ze względu na bardzo dużą amplitudę czoła fali (zjawisko tzw. „fali uderzeniowej” - przed rozchodzącym się czołem fali tworzy się pas
3
b.wysokiego ciśnienia, który musi być przekroczony przez samolot w chwili łamania bariery dźwięku).
4. Źródło porusza się ze stałą prędkością, większą niż prędkość rozchodzenia się fali.
[> wave4 := wave(10,1.5,1.5):
[> display(wave4,insequence=true,scaling=constrained, axes=none);
Źródło fali może być interpretowane jako samolot poruszający się z prędkością naddźwiękową. Obserwator zobaczy w takim wypadku przelatujący samolot, a kilka sekund później usłyszy falę uderzeniową
złożoną z nałożonych fal dźwiękowych powstających za samolotem. Gdy prędkość samolotu jest stała,
fala uderzeniowa powstająca za samolotem ma kształt stożka, tym bardziej wydłużonego, im większa
jest prędkość samolotu (SPRAWDŹ! - np. wave4 := wave(10,2.5,2.5):). Gdy samolot porusza się
ze stałym przyspieszeniem, kształt stożka fali uderzeniowej będzie zdeformowany, co można zaobserwować na następnej animacji.
5. Źródło przyspiesza, wyprzedzając rozchodzącą się falę.
[> wave5 := wave(15,0.5,2.5):
[> display(wave5,insequence=true,scaling=constrained, axes=none);
Źródło może być interpretowane jako samolot przełamujący barierę dźwięku i przyspieszający do prędkości Mach 2,5.
• Prosta symulacja ruchu układu planetarnego:
Wykonanie poniższego ciągu poleceń pozwala na wyświetlenie animacji ruchu czterech planet wokół centrum układu (na pasku narzędziowym pojawiającym się po zaznaczeniu animacji należy włączyć przycisk
umożliwiający
ciągłe, cykliczne odtwarzanie animacji).

> restart:

with(plots):
with(plottools):
[> dt:=200;
[> T:=4*Pi;

> for i to dt do

c0:=circle([0,0],0.4,color=yellow):


c:=circle([sin((T/dt)*i),cos((T/dt)*i)],0.05,color=blue):


c1:=circle([2*sin((T/dt)*2*i),2*cos((T/dt)*2*i)],0.1,color=red):


c2:=circle([1.5*sin((T/dt)*1.5*i),1.5*cos((T/dt)*1.5*i)],0.1,color=green):


c3:=circle([4*sin((T/dt)*4*i),4*cos((T/dt)*4*i)],0.02,color=black):
anim||i:=display([c0,c,c1,c2,c3]):od:
[> anims:=anim||(1..dt):
[> display([anims],insequence=true,scaling=constrained,axes=none);
UWAGA - używając programu Maple w wersji 5.1 należy operator konkatenacji łańcuchów ”||” zamienić na
”.”
Wykorzystano procedurę circle(c, r, options) z pakietu plottools zwracającą obiekt graficzny, który po wyświetleniu procedurą display reprezentuje okrąg o środku w punkcie c (punkt dany jako lista zawierająca
współrzędną x i współrzędną y środka) i promieniu r.
Ruch „planet” układu widocznego na animacji jest sprzeczny z danymi obserwacyjnymi oraz prawami ruchu
ciał w polu grawitacyjnym - np. okres obiegu planet wokół centrum układu powinien zmniejszać się wraz ze
wzrostem odległości od centrum układu. Dokonaj odpowiednich poprawek w kodzie symulacji, aby wynik był
jak najbardziej zbliżony do ruchu Układu Słonecznego (ilość planet, okresy obiegu, odległości od centrum
itp.).
4