Symulacja i modelowanie zachowania układów dynamicznych. Różniczkowanie.
Układy dynamiczne to takie, które zmieniają się w czasie. Przykładem szkolnym może być np. zachowanie ciała w polu grawitacyjnym. Program komputerowy będzie symulował zachowanie się ciał pod wpływem różnych sił zewnętrznych (satelita w polu grawitacyjnym, rzut ukośny z uwzględnieniem oporu powietrza, drganie oscylatora itp.). Będzie także umożliwiał odpowiedź na pytania typu: Jak poruszałaby się planeta, gdyby pole grawitacyjne było opisane innym wzorem? Jaki będzie tor pocisku, gdy zmieni się opór powietrza? itp.
|
vx:=vx+ax*dt; vy:=vy+ay*dt; x:=x+vx*dt; y:=y+vy*dt; |
Na lekcjach fizyki rozpatruje się te zagadnienia w sposób uproszczony. Uczeń otrzymuje gotowe wzory do zastosowania. Być może ułatwia to rozwiązywanie prostych zadań, nie pozwala jednak na zrozumienie zjawiska. Położenie ciała w dowolnym momencie opisują zmienne x,y,vx,xy (współrzędne i prędkość w układzie kartezjańskim). Mając te dane możemy obliczyć nowe wartości położenia i prędkości po upływie jakiegoś odcinka czasu - dt. Bardzo ważne jest to, aby odcinek czasu był na tyle krótki, żeby ruch można było traktować jako jednostajny. Gdy przyspieszenie ciała jest zmienne, nie można wyliczyć nowego położenia. Jest to tzw. rachunek różniczkowy. Nie wiemy gdzie znajdzie się ciało po dłuższym okresie czasu. Możemy jednak wyliczać kolejne położenia po krótszym okresie i tą drogą znaleźć położenie końcowe. Tak więc kolejne położenia i prędkości będzie można wyliczać wykonując w pętli proste rachunki.
Jest to algorytm Eulera numerycznego rozwiązywania równań różniczkowych. Definiując funkcje ax i ay (różne w zależności od rodzaju ruchu) możemy przy odpowiednio dobranych początkowych wartościach zmiennych x,y,vx,vy symulować zachowanie się satelity czy pocisku wystrzelonego z armaty.
Modelowanie.
Ma ono ogromne znaczenie ze względów praktycznych. Z reguły nie da się sprawdzić jak będą się zachowywały złożone systemy w rzeczywistości, bo albo ich jeszcze nie ma, albo jest to niemożliwe do przeprowadzenia. Przy użyciu komputera można symulować takie zjawiska i testować jak będą się zachowywały w różnych nieprzewidzianych sytuacjach. Model będzie tym prawdziwszy im więcej zależności mieścimy w programie
Będziemy na przykład analizować długości kolejek przy kasach. Problem przedstawia się w następujący sposób: Klient przychodzi do sklepu i dokonuje zakupu towarów. Ilość kupowanych przez klienta jednostek towaru jest przypadkowa (np. max. 50). Czas wybierania jednego towaru w sklepie też jest przypadkowy i trwa średnio np. 30 sekund. Po dokonaniu zakupu klient staje w kolejce do jednej z np. 3 kas. Zakładamy, że klient staje w najkrótszej kolejce, a w przypadku jednakowej długości w kasie o mniejszym numerze. Czas obsługi klienta w kasie zależy od ilości zakupionego towaru. Zakładamy, że na skasowanie jednej zakupionej jednostki potrzebny jest określony stały czas np. 30 sekund. Zakładamy, że kolejny klient przychodzi do sklepu nie później niż np. 3 minuty po poprzednim kliencie. Zakładamy, że sklep jest otwarty przez np. 8 godzin. Zakładamy, że w sklepie jest np. 15 koszyków dla klientów, reszta czeka przed sklepem. Należy przeprowadzić symulację długości kolejek w sklepie.
GRAF22.PAS
{symulacja ruchu w polu grawitacyjnym}
program grafika22;
uses crt,graph;
{centralne pole grawitacyjne}
function r3(x,y:real):real;
var r:real;
begin
r:=sqrt(x*x+y*y);
r3:=r*r*r;
end;
function ax(x,y,vx,vy:real):real;
begin
ax:=-200*x/r3(x,y);
end;
function ay(x,y,Vx,Vy:real):real;
begin
ay:=-200*y/r3(x,y);
end;
procedure symulacja(x0,y0,Vx0,Vy0,dt:real);
var x,y,Vx,Vy:real;
begin
x:=x0;
y:=y0;
Vx:=Vx0;
Vy:=Vy0;
repeat
{gdy chcemy samą planetę}
putpixel(320+round(x),240+round(y),0);
Vx := Vx + ax(x,y,Vx,Vy) * dt;
Vy := Vy + ay(x,y,Vx,Vy) * dt;
x := x + Vx * dt;
y := y + Vy * dt;
putpixel(320+round(x),240+round(y),15);
delay(10)
until keypressed;
end;
var
d,m:integer;
dt:real;
begin
d:=detect;
initgraph(d,m,'');
dt:=1;
{rysujemy słoneczko}
setcolor(14);
circle(320,240,1);
circle(320,240,2);
circle(320,240,3);
circle(320,240,4);
circle(320,240,5);
{planeta w ruch}
symulacja(-60,20,2.2,0.4,dt);
closegraph;
end.
GRAF23.PAS
{symulacja ruchu w polu grawitacyjnym}
program grafika23;
uses crt,graph;
{rzut ukośny}
function ax(x,y,Vx,Vy:real):real;
begin
ax:=-0.01*Vx-0.3;{wiatr}
end;
function ay(x,y,Vx,Vy:real):real;
begin
ay:=-0.01*Vy-1.5;{opór powietrza}
end;
procedure symulacja(x0,y0,Vx0,Vy0,dt:real);
var x,y,Vx,Vy:real;
begin
x:=x0;
y:=y0;
Vx:=Vx0;
Vy:=Vy0;
repeat
Vx := Vx + ax(x,y,Vx,Vy) * dt;
Vy := Vy + ay(x,y,Vx,Vy) * dt;
x := x + Vx * dt;
y := y + Vy * dt;
putpixel(320+round(x),240-round(y),15);
until keypressed;
end;
var
d,m:integer;
dt:real;
begin
d:=detect;
initgraph(d,m,'');
dt:=1;
line(0,460,640,460);{poziom ziemi}
symulacja(-300,-220,25,35,dt);
closegraph;
end.
GRAF24.pas
{symulacja ruchu w polu grawitacyjnym}
program grafika24;
uses crt,graph;
{oscylator}
function ax(x,y,Vx,Vy:real):real;
begin
ax:=-0.03*x-0.01*Vx;
end;
function ay(x,y,Vx,Vy:real):real;
begin
ay:=-0.5*y;
end;
procedure symulacja(x0,y0,Vx0,Vy0,dt:real);
var x,y,Vx,Vy:real;
begin
x:=x0;
y:=y0;
Vx:=Vx0;
Vy:=Vy0;
repeat
{gdy chcemy sam punkt}
putpixel(320+round(x),240+round(y),0);
Vx := Vx + ax(x,y,Vx,Vy) * dt;
Vy := Vy + ay(x,y,Vx,Vy) * dt;
x := x + Vx * dt;
y := y + Vy * dt;
putpixel(320+round(x),240+round(y),15);
delay(10);
until keypressed;
end;
var
d,m:integer;
dt:real;
begin
d:=detect;
initgraph(d,m,'');
dt:=0.1;
symulacja(-320,0,0,60,dt);
closegraph;
end.