# Fizlab (MyPhysicsLab.hu) Egyszerű hullámvasút

This page is part of the website prepared by Sándor Nagy with kind permission from Erik Neumann as a translation to Hungarian of his original site MyPhysicsLab—Physics Simulation with Java.
Nagy Sándor megjegyzése: Ezt a lapot (a szimulációkezelést kivéve) még nem volt időm magyarítani. ♦ This page is planned to be but has not yet been translated to Hungarian.

Akik túl vannak már két szemeszternyi fizikán az egyetemen, ill. főiskolán (vagy esetleg emelt szinten tanulták a gimnáziumi fizikát), azok alighanem rengeteg olyan feladatot megoldottak már, amelyek lejtős síkon leguruló golyókról szóltak. De talán még ők sem gondolkodtak el azon, hogyan is oldhatók meg az olyan feladatok, amelyek esetében a mozgás görbült felületen zajlik. Természetesen az ilyen mozgásokra is ugyanazok az alapelvek érvényesek, mint az egyenes vonalú mozgásokra, csakhogy a lejtő meredekségváltozása magukra az erőkre is kihat. Ezért a dolog matekos oldala kissé bonyolultabb, ám ugyanakkor érdekesebb is!

A pálya alakját a szimuláció alatti ikonokra kattintva választhatjuk ki a legegyszerűbben. Változtatható paraméterek a golyó (igazából tömegpont) tömege, a gravitáció és a csillapítás (súrlódás). Az egérrel változtatni lehet a golyó kiindulási helyzetét is.
Ha nem jön elő a szimuláció, akkor érdemes elolvasni a Java engedélyezéséről szóló instrukciókat. A kapcsolatos fizikát és matekot lásd lentebb.

A pályaalak kiválasztása kattintással:
 Hupli Hurok Kör Végtelenjel Ovális Spirál

## Jól működik a szimuláció? Lássuk az energiamegmaradást!

Hogyan tudhatjuk meg, hogy a szimuláció jól működik-e? Egy biztos, a golyó magától nem veszíthet energiát, de nem is nőhet az energiája valamely rejtélyes oknál fogva. Ezért érdemes ellenőrizni azokat a szituációkat, amelyek leleplezhetik az energiamegmaradási elv megsértését.

Húzzuk fel a golyót a pályán bizonyos magasságig, aztán engedjük el. Ha a csillapítás (súrlódás) 0-ra van állítva, akkor a golyónak újra meg újra ugyanaddig a magasságig kell visszatérnie miközben ide-oda mozog a pályán. Az irányváltás pillanataiban sem nyerhet vagy veszíthet energiát. A megfordulás pillanatában a sebesség 0, ezért az összes energia gravitációs (= potenciális = helyzeti) energia.

Tegyünk egy még érzékenyebb próbát: Kattintsunk a körpályára. Állítsuk a csillapítást 0-ra (ha más értéken van), vigyük a golyót a pálya legfelső pontjára (amennyire sikerül), majd eresszük el. Az elengedés pillanatában a golyónak 0 a sebessége, ezért csak potenciális (gravitációs) energiával rendelkezik. A golyó elindul lefelé valamelyik irányban, aztán a legalsó ponton túlszaladva fölfelé megy a másik oldalon csaknem elérve azt a pontot, ahonnan elindítottuk. Ha minden stimmel, akkor itt irányt kell váltania, és arra kell visszagurulnia, amerről jött.

Ha nem ez történik, hanem a golyó a legfelső ponton túlkecmeregve tovább folytatja útját, abból tudni lehet, hogy egy pici energianyereségre tett szert, hiszen a pálya csúcspontján most 0-nál nagyobbnak kellett lennie a sebességének (holott eredetileg 0 volt). Az ilyen esemény a szimulációt hibásnak mutatná.

Ahhoz, hogy az energiát közvetlenül "láthassuk", jelöljük ki az Energiaváltozó négyzetét. Az ilyenkor látható (számított) energiaérték a kinetikus (mozgási) energia és a gravitációs (helyzeti) energia összegét jelenti. Kinetikus energia = 12 m v2
Gravitációs energia = m g y
ahol m = tömeg, v = sebesség, g = gravitációs állandó és y = függőleges helyzet (magasság). Ha a csillapítást kiiktatjuk, akkor a golyó összes energiájának nem szabad változnia mozgás közben. Ehelyett azt látjuk, hogy az összes energia folyamatosan ingadozik. Ezt azok az egyszerűsítések okozzák, amelyeket a szimuláció programozásakor elkövettem. Például a görbe táblázat formájában (tehát nem folytonos függvényként) szerepel a programban (lásd lentebb), és a görbe meredekségét kissé durván közelítjük az egyes pályapontokban.

Ez a példa talán tanulságos lehet abból a szempontból, hogy egy szimuláció programozása mindig kompromisszumot jelent a (fizikai) korrektség, az ábrázolás gyorsasága és a programozásba fektetett munka között!

## Az Egyszerű hullámvasút fizikája

A ball moves along a curved track. We assume that the ball cannot leave the track, but is free to move along its length. We have two variables
• p = position on the track (measured by path length along the track)
• v = velocity
We pick some point on the track to be position p = 0 and pick a direction along the track to be positive. Then the position is equal to the length of the track, from the origin to that point. The gravity force on the ball is shown in the diagram as m g pointing downwards. The component of this force that is parallel to the track is what causes the ball to accelerate. The steeper the track, the faster the acceleration.

Let k be the slope of the track at this point. Let θ be the angle between the gravity vector and the slope vector (the slope vector points in the direction where p increases). Then we can write the force equation for gravity as
 F = m a = m g cos θ (1)
where m = mass, a = acceleration, and g = the gravitational constant. If we add a damping (friction) force that is proportional to the velocity we get
 F = m a = m g cos θ − b v (2)
where b is a constant determining the amount of damping. We can find cos θ by using the formula for the angle between two vectors A, B
 cos θ = A · B |A| |B|
where the numerator is the dot product, and the denominator is the product of the lengths. (Note that we indicate vectors with bold letters here.) Define our two vectors by
• A = (1, k) the slope vector, pointing in the direction of increasing p
• B = (0, −m g) the gravity vector
 cos θ = −k m g = −k m g √(1 + k2) √(1 + k2)
Now we can write equation (2) as
 a = −g k − b⁄m v √(1 + k2)
(3)
where we keep in mind that the slope k is really a function of position k(p). That is, given the position, we need to find the slope at that point. This is the equation of motion for the roller coaster.

## Numerical Simulation

The two equations needed for the Runge-Kutta numerical solver are given by: p' = v
 v' = −g k(p) − b⁄m v √(1 + k(p)2)
Here we indicate that the slope k is a function of position p by the notation k(p).

There is a small additional complication in that the track can loop around. This requires us to determine whether the path is increasing (in the sense of increasing p) to the left or to the right. This affects the direction of the slope vector and can change the sign of cos θ. This enters into the first term of equation (3) as a possible multiplication by −1.

Finally, vertical lines need a special treatment, because the slope is infinite there. When we detect that the slope is vertical, equation (3) becomes: a = −gbm v

## Measuring the Length of a Curve

To program this simulation on the computer we need to find the relationships between:
• p = position (measured by path length)
• k = slope of the track
• (x, y) = position in 2 dimensional space
For the correctness of the simulation, the most important relationship is pk because this is used in the differential equation, represented by the function k(p). The other relationships can be less exact because they are only used to update the graphics or for user input. For example, the relation p → (x, y) is used to update the graphics. And the relation (x, y) → p is used for dragging the ball.

Suppose that the curve can be defined parametrically by two functions x(t), y(t). That is, to sweep out the curve we increase the variable t from 0 to some value. And for each value of t we can find the position of the curve from the functions x(t), y(t). For example, a circle can be defined parametrically by x(t) = cos t
y(t) = sin t
where t varies from 0 to . In two dimensions, the length of a curve can be determined by the path integral where the limits of integration are the starting and ending value of t corresponding to the points you want to measure between.

We can try to solve the path integral analytically to get the needed relations. For some curves this is easily done. For the circle, the path integral is especially simple: p = ∫ √ (sin2t + cos2t) dt = ∫ 1 dt = t But for most curves the integral is too difficult to solve. For example, the "hump" curve in the simulation is defined by a simple polynomial x(t) = t
y(t) = 3 − 76 t 2 + 16 t 4
But this leads to the following nasty integral which even Mathematica cannot solve. Faced with difficult integrals, we instead take an approximate numeric approach and construct a table to represent the curve, as explained below.

## Representing the Curve with a Table

Here is how we construct a table to represent the curve. Assume we have the functions x(t), y(t) which describe the curve parametrically. Suppose we want the curve to be defined from t = −3 to t = 3. Then we start forming a table that would look something like this:
T P X Y
−3 0 1 2
−2.99 0.014142 0.99 2.01
−2.98 0.028284 0.98 2.02
. . . . . . . . . . . .
Each row of the table represents a point on the curve. The table is constructed by starting with t = −3 and setting p = 0. We then find x, y from the equations x(−3), y(−3). To add each row, we increase t by some small increment (here it is 0.01) and find the corresponding x(t), y(t). We can then find p either by numerically evaluating the path integral (see above), or as a cruder and simpler method we can just increase p by the distance to the previous x, y point. I've chosen the simple, crude method for the program here (a refinement would be to fit a polynomial to 3 or 4 neighboring points).

Once we have the table, we can implement a routine that maps pk. This can be done quickly by using a binary search algorithm, since the p values are all sorted. Suppose that p is closest to the i-th value in the table, so that P[i] < p < P[i+1] where P represents the list of p values in the table. Then an approximate value for the slope is given by
 k = Y[i+1] − Y[i] X[i+1] − X[i]
where X, Y are the tables of x, y values. Similar methods can be used for finding the relation p → (x, y). For slightly better accuracy we can use a polynomial interpolation of the 4 points in the table that are nearest to the value of p we are seeking.

The routine that maps (x, y) → p is used less frequently and doesn't need to be as efficient. I use a linear search through the entire table to find the point in the table that minimizes the distance from the given (x, y) to the curve.

Látogatószám 2013.02.27. óta:

WebCounter