Simulering av solsystemet Datorlab med MATLAB. Daniel Vågberg Institutionen för fysik Umeå Universitet

Transkript

1 Simulering av solsystemet Datorlab med MATLAB Daniel Vågberg Institutionen för fysik Umeå Universitet 17 april 2013

2 Innehåll Introduktion 3 Redovisning 3 Simulering av Newtons rörelseekvationer 4 Gravitation 6 Uppgifter 8 Uppgift 1: Simulering av satellit Uppgift 2: Omloppstiden Uppgift 3: Tvåkroppsproblemet Uppgift 4: Solsystemet Appendix 12 Verlet-integration Velocity-Verlet Exempelkod

3 Introduktion Er uppgift är att simulera ett planetsystem i MATLAB och mäta olika egenskaper på systemet. Instruktionerna börjar med en genomgång av de numeriska metoder som ska användas och fortsätter sedan med hur man tillämpar dem på den typ av gravitationsproblem vi är intresserade av. Efter det kommer själva uppgifterna. Syftet med uppgifterna är dels att ni ska bli bättre på att använda MATLAB till fysikaliska simuleringar och dels att ni ska få undersöka ett fysikaliskt system och se hur olika kvantiteter (tex energi och rörelsemängd) bevaras över tid. Till vissa uppgifter kommer ni behöva data för planeterna tex jordens och solens massa, dessa kan tas ifrån tex Physics Handbook, ange alltid vilka värden ni använder och varifrån de kommer. Redovisning Ni jobbar två och två och lämna in en skriftlig redovisning tillsammans. Rapporten behöver inte följa en strikt rapportmall, men det måste tydligt gå att följa och förstå vad ni gjort. Rapporten ska innehålla svar på samtliga frågor. Svaren ska vara tillräckligt utförliga så man kan förstå dem utan att ha tillgång till själva frågan. Figurer som efterfrågas i uppgifterna ska nnas med i rapporten. Ni får naturligtvis även lägga till egna gurer där ni tycker det passar. Den MATLAB-kod ni använder för att lösa problemen ska nnas med i rapporten. Längre kod kan med fördel läggas i ett appendix i slutet av rapporten. Glöm inte att kommentera MATLAB-koden. Ange vilka data ni använder för planeterna och varifrån de kommer. Rapporten skickas in som pdf-l Glöm inte att skriva namn och på rapporten! 3

4 Simulering av Newtons rörelseekvationer Vi börjar med att studera rörelse i en dimension, när vi löst det endimensionella fallet är det enkelt att generalisera lösningen till två eller tre dimensioner. Antag att vi har ett föremål med position x, hastighet v och acceleration a. Vi vill beräkna hur föremålets position förändras över tiden, vi vet föremålets position och hastighet vid tiden t = 0. Accelerationen hos ett föremål beskrivs av Newtons andra lag F = ma a = F m, (1) där F är kraften som påverkar föremålet, m är föremålets massa och a är föremålets acceleration. Accelerationen denierats som andraderivatan av positionen a = d2 x dt 2. (2) Om vi känner till systemets position och hastighet vid tiden t = 0 och accelerationen (eller kraften) är en känd funktion kan vi lösa ovanstående dierentialekvation och se hur positionen x varierar med tiden. För vissa problem går ekvationen att lösa för hand, men för mer avancerade problem eller problem med många föremål som rör sig samtidigt är ofta enda lösningen att använda datorhjälpmedel. Ekvation 2 är en andra ordningens dierentialekvation. Den går att skriva om som två kopplade första ordningens dierentialekvationer genom att införa hastigheten v som en hjälpvariabel. Problemet som ska lösas blir då dx(t) = v(t) dt dv(t) dt = a(t) där initialvärden x(0) = x 0 och v(0) = v 0 är kända, och a(t) är en känd funktion. Både ekvation 2 och 3 beskriver samma fysik. Numeriskt är det ofta lättare att hantera första ordningens dierentialekvationer så vi kommer använda ekvation 3 som grund för våra simuleringar. Notera att den numeriska metoden vi ska använda förutsätter att kraften F är konservativ. För att lösa problemet numeriskt måste vi diskretisera problemet. Vi börjar med att dela in tiden i diskreta punkter t 0, t 1, t 2..., t n, t n+1,... mellan varje punkt är det en konstant tidsskillnad t så att t 0 = 0, t 1 = t,..., t n = n t. För att förenkla notationen kommer vi använda beteckningen x n för x(t n ) och v n för v(t n ) osv. Det den numeriska metoden kommer göra är att hitta en approximativ lösning till ekvation 3. Grundidén är att om vi vet var vi är vid tiden t n kan vi approximera var vi kommer vara vid tiden t n+1 och på så sätt stega oss framåt i tiden. Detta görs genom att approximera derivator, vi kan till exempel approximera förändringen i x vi tiden t n med dx dt x(t n + t) x(t n t) = xn+1 x n 1 2 t 2 t Steglängden t avgör hur bra approximationen blir och vi ser att om t 0 blir derivatan exakt. Men om vi tar väldigt små tidssteg kommer simuleringen att ta lång tid eftersom vi måste ta er steg för att simulera samma mängd tid. (3) (4) 4

5 Konsten är att välja ett t som är litet nog för att ge en bra approximation men samtidigt inte för litet så att simuleringen tar orimligt lång tid att köra. Integrationsmetoden vi ska använda heter Velocity-Verlet, och bygger på två rekursiva uppdaterings formler som används för att stega framåt i tiden. De två formlerna en för positionen och en för hastigheten återges här nedan x n+1 = x n + v n t an t 2 ( v n+1 = v n a n + a n+1) (5) t En härledning av Velocity-Verlet metoden nns i appendix efter uppgifterna, läs gärna igenom den, det är bra om man vet vilka antagnaden som ligger bakom en metod man använder så man inte råkar ut för överraskningar. Det är trivialt att utöka systemet till er dimensioner, rörelsen i de olika riktningarna är bara kopplade genom kraften som är positions beroende i övrigt är rörelsen i de olika riktningarna oberoende av varandra. För två dimensioner får vi fyra uppdaterings ekvationer x, y, v x och v y x n+1 = x n + vx n t an x t 2 y n+1 = y n + vy n t an y t 2 v n+1 x = v n x v n+1 y = v n y ( ) (6) a n x + a n+1 x t ( ) a n y + a n+1 y t Mer allmänt kan vi skriva om uppdaterings relationerna på vektorform, r n+1 = r n + v n t a(rn ) t 2 ( v n+1 = v n a(r n ) + a(r n+1 ) ) t (7) där r är positionsvektorn, v är hastighets vektorn och a(r) är en känd funktion som beräknar accelerationsvektorn utifrån en given positionsvektor. Ekvationerna ovan gäller för rörelsen av en enskild partikel/föremål, men vi kan utöka dem till att gälla era partiklar. Antag att vi har två partiklar med position r 1 och r 2 och som växelverkar genom accelerationen dvs a(r 1, r 2 ) då får vi följande r n+1 1 = r n 1 + v1 n t a 1(r n 1, r n 2 ) t 2 r n+1 2 = r n 2 + v2 n t a 2(r n 1, r n 2 ) t 2 v n+1 1 = v n v n+1 2 = v n ( a1 (r n 1, r n 2 ) + a 1 (r n+1 1, r n+1 2 ) ) t ( a2 (r n 1, r n 2 ) + a 2 (r n+1 1, r n+1 2 ) ) t Har man er partiklar är det bara att fortsätta lägga till er ekvationer. Det ser mycket ut när man skriver ut ekvationerna så här men när man programmerar behöver man bara skriva in ekvationerna en gång, har man era partiklar löser man det med en loop eller ännu bättre ordnar datat i vektorer så man kan använda MATLABs inbyggda vektoroperationer istället. Dvs när ni skriver programmet är det bara de fyra uppdateringsformlerna i ekvation 6 som ni behöver använda, har ni era partiklar så löser ni det genom att vektorisera ekvationerna. (8) 5

6 Gravitation Hittills har vi talat ganska allmänt om hur man simulerar Newtons-rörelseekvationer, men nu ska vi bli lite mer specika och fokusera på det problem vi ska jobba med dvs gravitationkrafter och planetbanor. Det vi behöver för att använda Velocity-Verlet-metoden är ett uttryck för accelerationen och hur den varierar med positionen. Eftersom a = F/m börjar vi med att specicera vilka krafter vi har. Antag att vi har två planeter i och j med massa m i och m j. Gravitationskraften F ij mellan planeterna ges av F ij = G m im j rij 2 ˆr ij, (9) där G är gravitationskonstanten, r ij är avståndet mellan objekten och ˆr ij är en enhetsvektor som pekar från planet i mot planet j. Eftersom kraft och motkraft måste balansera så vet vi att F ij = F ji. Vi ska lösa problemet i två dimensioner så r ij ges av r ij = r j r i = (x j x i ) 2 + (y j y i ) 2 (10) För att kunna använda lösningsmetoden i ekvation 6 måste vi komposantuppdela kraften. I gur 1 ser vi kraftvektorn ut ritad för planet i. De två kraftkomposanterna på planet i ges av F x = F ij cos θ = F ij x i x j r ij F y = F ij sin θ = F ij y i y j r ij = Gm i m j x i x j r 3 ij = Gm i m j y i y j r 3 ij (11) från dessa kan vi sedan beräkna accelerations komposanterna a x = Fij m i cos θ = Fij x i x j m i r ij a y = Fij m i sin θ = Fij y i y j m i r ij = Gm j x i x j r 3 ij = Gm j y i y j r 3 ij (12) Vi ser att accelerationen av planet i är oberoende av planetens egen massa m i. Vi noterar också att vi aldrig behöver räkna ut vinkeln θ. Nu har vi allt vi y m j r ij = r j r i r j F x F ij θ F y m i r i x Figur 1: Figuren visar de två planeterna i och j, tillsammans med dess positionsvektorer r i och r j, till planet i har även kraftvektorn ritats ut. 6

7 behöver för att simulera rörelsen av två himlakroppar som påverkar varandra via gravitationen. Om vi har mer än två planeter så kommer alla planeter att påverka varandra. För att få den totala kraften som påverkar en planet måste vi summera kraften från alla andra planeter. Antag att vi har N planeter den total kraften på planet i ges då av N F i = F ij (13) Nu när vi har allt vi behöver för att simulera rörelsen för ett godtyckligt antal himlakroppar ska vi bara snabbt gå igenom olika kvantiteter som vi kan vilja mäta i vårt system. Lättaste sättet testa att en simulering fungerar som den ska är att kontrollera att energin bevaras i systemet. Vi har två typer av energi i systemet, kinetisk energi som ges av och potentiellenergi som ges av E k = E p = G Den totala energin i systemet E ges av j N i N i m i v 2 i 2 N j>i (14) m i m j r ij (15) E = E k + E p (16) Om allt fungera som det ska och systemet inte påverkas av några yttre krafter ska E vara konstant genom hela simuleringen. En annan kvantitet som också bevaras förutsatt att inga yttre krafter verkar på systemet är den totala rörelsemängden p som ges av N p = m i v i (17) i En tredje bevarad kvantitet är rörelsemängdsmomentet N L = r i m i v i (18) i som bevaras om systemet inte påverkas av några vridmoment skapade av yttre krafter. L är en vektor som är vinkelrätt mot både r och v. För ett tvådimensionellt system, dvs ett systemet som är begränsat till att bara röra sig i xy-planet, kommer L endast bestå av en z-komponent. Att kontrollera att de tre kvantiteterna E, p och L bevaras är ett mycket bra test som hjälper en att hitta eventuella fel i simuleringen. Att de bevaras är dock ingen garanti på att allt är rätt, men om någon av dem inte bevaras så är det denitivt ett tecken på att något är fel. En annan intressant kvantitet man kan studera är hur masscentrum för hela systemet rör sig. Vi kan beräkna masscentrums position genom 1 N r CM = N m i r i (19) i m i Om inga yttre krafter verkar på systemet och den totala rörelsemängden p är noll kommer masscentrum att stå still. i 7

8 Uppgifter Målet med uppgifterna är att vi ska skriva en simulering där vi kan simulera rörelsen för solen och de inre planeterna i solsystemet. Vi ska bygga upp simuleringen stegvis och börjar först med några enklare fall som vi sedan kan bygga vidare på för att få den fulla lösningen. Uppgift 1: Simulering av satellit Vi ska börja med att simulera en satellit i omloppsbana kring en planet. Vi antar att planeten väger mycket mer än satelliten och att planetens rörelse därför inte kommer påverkas nämnvärt av satelliten. I vår simulering kommer vi därför anta att planeten står stilla och att det bara är satelliten som rör sig. Detta är förstås en approximation. I nästa uppgift ska vi även simulera planetens rörelse och se hur den påverkar resultatet. y F x m r F F y θ M x Figur 2: En liten satellit i omloppsbana kring en planet. Vi ska simulera systemet under antagandet att m M. Skriv en funktion orbit_1body som simulerar banan för en satellit med massa m i omloppsbana kring en planet med massa M. Vi antar att m M så att planetens rörelse kan försummas. Planeten står still, och är placerad i origo. Rörelseekvationerna ska integreras med hjälp av Velocity- Verlet. Funktionen ska använda följande funktionshuvud: function [x,y,vx,vy,t]=orbit_1body(g,m,x0,y0,vx0,vy0,dt,tmax) där G är gravitations konstanten, M är massan hos planeten, x0, y0, vx0 och vy0 beskriver satellitens position och hastighet vid tiden t = 0. Variabeln dt är längden på tidsteget och tmax är den totala tiden att simulera dvs vi ska simulera systemet från t = 0 till t =tmax. Notera att satellitens bana är helt oberoende av satellitens egen massa m. Funktionen returnerar fem vektorer x och y som innehåller satellitens koordinater en datapunkt för 8

9 varje tidsteg i simuleringen, vx och vy som innehåller satellitens hastighet för varje tidsteg, samt t som innehåller tiden för varje datapunkt. På sista sidan i instruktionerna nns ett kodexempel som går att använda som utgångspunkt om ni känner er osäkra på hur ni ska börja. Testkör funktionen med följande parametrar och initialvärden: G=1, M=10, m=0.01, x0=10 y0=0 vx0=0, och vy0=0.75, välj tmax så att satelliten hinner ca 5-10 varv runt planeten under simuleringen. Rita upp satellitens bana, och markera planetens position i guren. Simulera med olika värden på dt och se hur noggrannheten i simuleringen förändras. Vilket värde på dt verkar lämpligt att använda? Kontrollera att energin bevaras i simuleringen, plotta E k, E p och E p + E k och se hur de förändras med tiden. Kontrollera att rörelsemängdsmomentet är bevarat för systemet. Kontrollera att rörelsemängden bevaras i systemet. Får vi det förväntade resultatet? Om inte förklara vad som händer i systemet. Uppgift 2: Omloppstiden Vi ska nu beräkna omloppstiden för satelliten i föregående uppgift utifrån våra simulerings resultat. Vi kommer behöva räkna ut er omloppstider i de följande uppgifterna vi ska därför automatisera den processen genom att skriva en funktion som gör jobbet åt oss. Skriv en funktion som beräknar omloppstiden givet koordinatvektorerna x, y och tidsvektorn t som genererats av funktionen orbit_1body. Detta går att göra på era olika sätt. Beskriv vilken algoritm ni använder i rapporten. (Tips börja med att plotta x och/eller y mot tiden för att avgöra vilken egenskap hos kurvorna som kan användas för att beräkna omloppstiden.) Testkör funktionen, använd data med samma initialvillkor som i föregående uppgift. Vilken omloppstid har satelliten? Hur påverkas omloppstiden om satellitens initialhastighet ökar? Vid vilken hastighet slutar satelliten att gå i omloppsbana runt planeten? Vad är den totala energin i systemet när det händer? Simulera med samma initialvillkor som tidigare men öka stegvis värdet på vy0. Kontrollera hur omloppstiden och den totala energin E k + E p varierar. Vi ska nu testa vår kod på ett verkligt exempel: Rymdstationen ISS (International Space Station) ligger i en nästan cirkulär omloppsbana kring jorden. Omloppsbanan är en så kallad LEO (Low Earth Orbit) vilket innebär att stationens omloppsbanan ligger strax utanför atmosfären på ca 400km höjd över jordytan. Stationen väger ca 450ton och har en medelhastighet av 7700m/s. Simulera stationens rörelse, anpassa dt så att ni får en stabil lösning. Vilken omloppstid har stationen? 9

10 Uppgift 3: Tvåkroppsproblemet Nu ska vi utöka vår simulering så att vi även simulerar planetens rörelse. Eftersom vi simulerar rörelsen hos båda kropparna behöver vi inte göra några antaganden om hurvida satelliten väger mer eller mindre än planeten. Vårt system kommer nu se ut som i gur 1. Skriv en funktion orbit_2body som simulerar rörelsen hos två himlakroppar med hjälp av Velocity-Verlet-metoden, utgå från er tidigare simulering. Funktionen ska använda följande funktionshuvud: function [x,y,vx,vy,t]=orbit_2body(g,m,x0,y0,vx0,vy0,dt,tmax) Skillnaden mot tidigare är att vi nu har två kroppar som rörsig, vilket betyder att vi behöver dubbelt så många initialvillkor. Variablerna m, x0, y0, vx0 och vy0 kommer därför vara vektorer med två element. Till exempel den initiala x-positionen för den första kroppen anges i det första elementet x0(1) och motsvarande data för den andra kroppen anges i x0(2) osv. Vektorerna x, y, vx och vy som funktionen returnerar innehåller data för rörelsen hos båda kropparna och har dimensionen 2 steps där steps är antalet tidssteg i simuleringen. Testkör funktionen med samma initialvärden som i uppgift 1. För planeten innebär det m(1)=10, x0(1)=0, y0(1)=0, vx0(1)=0 och vy0(1)=0. Satellitens initialvärden är samma som i uppgift 1 och placeras på position 2 i vektorerna tex m(2)=0.01. Rita upp satellitens och planetens bana i samma gur och jämför med resultatet från uppgift 1. Undersök planetens rörelse, har den en sluten bana? om inte vad beror det på? Testa att öka massan på satelliten till m(2)=1 för att få en tydligare eekt. Vad händer med masscentrum? Vad måste vara uppfyllt för att masscentrum ska stå still? Räkna ut vilken initialhastighet planeten behöver för att masscentrum ska stå still. Simulera med de nya initialvillkoren och veriera att det fungerar. Hur förändras planetens bana? Gör en gur som visar planetbanan före och efter förändringen. Kontrollera att energin är bevarad. Kontrolera att rörelsemängdsmomentet är bevarat. Kontrolera att rörelsemängden är bevarad. Rita en gur med tre kurvor, rörelsemängden för satelliten, rörelsemängden för planeten och deras totala rörelsemängd. 10

11 Uppgift 4: Solsystemet Nu är vi redo att simulera solsystemet. Vi ska utöka simuleringen så att den kan hantera rörelsen hos N planeter som alla påverkar varandra genom gravitationen. och sedan testa simuleringen genom att simulera de inre delarna av solsystemet. Skriv en funktion force som beräknar kraften för alla N planeterna. Funktionen ska använda följande funktionshuvud function [f]=force(g,m,x,y) där f, m, x och y är vektorer med längd N. Där m innehåller planeternas massor, x och y är planeternas positioner, G är gravitationskonstanten och f är den totala kraften som verkar på varje planet som räknas ut genom att summera kraften från alla andra planeter enligt ekvation 13. Skriv en funktion orbit_nbody som simulerar rörelsen hos N st himlakroppar, med hjälp av Velocity-Verlet-metoden, utgå från er tidigare simulering och använd funktionen force för att beräkna kraften mellan planeterna. Funktionen ska använda följande funktionshuvud: function [x,y,vx,vy,t]=orbit_nbody(g,m,x0,y0,vx0,vy0,dt,tmax) In parametrarna är samma som tidigare med skillnaden att massan och initialvärdena nu är vektorer med längd N eftersom vi nu har N kroppar som behöver initieras. Av samma anledning har nu returvärdena dimension N steps för att kunna hålla banorna för de N himlakropparna vi simulerar. Testkör simuleringen med två kroppar och samma initialvillkor som i uppgift 3. Kontrollera att det blir samma resultat som i uppgift 3. Simulera solsystemet! Simulera solen och de inre planeterna Merkurius, Venus, Jorden och Mars. Dvs vi har N = 5, använd Physics Handbook eller annan källa för att hitta lämpliga initialvärden för planeterna. För att förenkla valet av initialvärden kan vi anta att alla planeterna ligger på en rad vid tiden t = 0. Solens hastighet bör väljas så att den totala rörelsemängden i systemet blir noll. För den här uppgiften räcker det om ni använder planeternas medelhastighet och medlavstånd från solen som initialvärden, men då kommer banorna att bli cirkulära istället för elliptiska. (För att få korrekta elliptiska banor behöver vi veta avståndet till solen och planetens hastigheten i en specik punkt på banan i stället för medelvärdet beräknat över hela banan) Välj tidsteg dt så att alla planeterna får en stabil bana, hur kort tidsteget måste vara bestäms av den snabbaste rörelsen i systemet, i det här fallet Merkurius. Gör en gur som visar planeternas banor. Kontrollera att energi, rörelsemängd och rörelesmängdsmoment bevaras. Gör tre gurer en för vardera kvantitet, gurerna ska innehålla en kurva för varje himlakropp och en kurva med det totala värdet. Beräkna omloppstiderna och jämför med tabellvärden. 11

12 Appendix Verlet-integration Vi ska nu härleda en metod för att integrera accelerationen och beräkna banan som ett föremål kommer att följa, vi antar att vi vet föremålets position och hastighet vid t = 0. Vi utgår ifrån Newtons andra lag d 2 x dt 2 F (x(t)) = a(x(t)) = m (20) där F (x(t)) är en konservativ kraft som endast beror på positionen x. Vi diskretiserar tiden och approximerar andraderivatan enligt följande a(x) = d2 x dt 2 x n+1 x n t xn x n 1 t t = xn+1 2x n + x n 1 t = a n (21) Om vi löser ut x n+1 får vi x n+1 = 2x n x n 1 + a n t 2 (22) vilket är en fullt fungerande integrations metod som kan användas för att räkna ut framtida positioner x n+1 givet de två föregående positionerna x n och x n 1 och accelerationen. Metoden har utvecklats era gånger av olika forskare genom historien men kallas oftast Verlets metod efter den senaste upptäckaren som gjorde metoden känd men man kan även se andra namn som tex Störmers metod. Verlets metod använder bara positionen och accelerationen för att räkna ut nästa position, hastigheten används inte. Detta har både för och nackdelar beroende på vilken typ av problem vi vill lösa. Om vi inte behöver känna till hastigheten är metoden mycket eektiv eftersom det går att räkna ut positionen direkt utan att gå omvägen via hastigheten. Men om vi behöver hastigheten blir det lite omständigt. Hastigheten går att räkna ut från skillnaden mellan två positioner: v n = xn+1 x n 1 2 t (23) men vi ser att för att räkna ut den nuvarande hastigheten v n måste vi redan känna till den nya positionen x n+1, vilket inte alltid är praktiskt. En annan sak att tänka på är att oftast känner man bara till en position vid t = 0 så för att komma igång måste x n 1 först beräknas med hjälp av någon annan metod. För att metoden ska fungera måste t vara konstant under hela simuleringen. Ändrar man tidsteget under simuleringen kommer partikelns rörelse att bli felaktig om man inte samtidigt skalar om de andra termerna för att kompensera för förändringen. Velocity-Verlet Det går att skriva om Verlets metod så att man får ut hastigheten direkt, metoden kallas då Velocity-Verlet. Det är en populär metod som ofta används för att simulera rörelsen hos tex molekyler. Vi utgår ifrån den vanliga Verlet metoden och börjar med med att lösa ut x n 1 från ekvation 23, vi får då x n 1 = x n+1 2v n t (24) 12

13 Vi sätter in uttrycket för x n 1 i ekvation 22 vilket ger x n+1 = x n + v n t an t 2 (25) som är en ny uppdaterings metod för positionen som även beror på hastigheten. Men för att få en fungerande metod behöver vi även veta hur vi ska uppdatera hastigheten. Utifrån ekvation 23 kan vi sätta upp ett uttryck för v n+1 : v n+1 = xn+2 x n 2 t (26) Vi kan ta fram uttryck för x n+2 och x n från ekvation 25 och sätta in dem i ekvation 26 vilket ger ( x v n+1 n+1 + v n+1 t = an+1 t 2) ( x n+1 v n t 1 2 an t 2) (27) 2 t Vilket efter förenkling blir v n+1 = v n ( a n + a n+1) t (28) Vi har nu två uppdateringsekvationer: x n+1 = x n + v n t an t 2 ( v n+1 = v n a n + a n+1) t (29) som tillsammans utgör metoden vi kallar Velocity-Verlet. Metoden är själv startande, dvs vi behöver inte använda en separat metod för att beräkna x n 1 eftersom det värdet aldrig används till skillnad från i den vanliga Verlet metoden. Även Velocity-Verlet kräver ett konstant t för att fungera korrekt. Man bör också vara medveten om att metoden bygger på antagandet att kraften är konservativ, dvs att kraften går att skriva som gradienten av en potential, F = V (r), där r är positions vektorn, och V är en funktion som beskriver den potentiella energin i systemet. De krafter (gravitation) vi ska simulera är konservativa så det antagandet är ingen begränsning för oss i det här fallet. Men problem kan uppstå om man har icke konservativa krafter som till exempel friktion eller luftmotstånd. Slutligen ska vi bara nämna att det nns en annan populär metod som kallas Leapfrog som också går att härleda genom att göra en omskrivning av Verletmetoden. Velocity-Verlet och Leapfrog är väldigt lika och har i princip samma egenskaper. 13

14 Exempelkod Här nedan återges ett exempel på strukturen i ett program som använder stegningsmetoder liknande Velocity-Verlet. Koden är tänkt att simulera en planet med rörelse i två dimensioner x och y. Syftet med koden är att ge lite tips om hur ni kan börja med uppgiften, men för att inte göra uppgiften för lätt är era rader kapade och avslutas istället med... %starting point for a simple simulation program %preallocate memory (increases performance) steps=... %select number of time steps x=zeros(1,steps); y=zeros(1,steps); vx=zeros(1,steps); vy=zeros(1,steps); %set initial conditions x(1)=... y(1)=... vx(1)=... vy(1)=... %define functions for calculating acceleration based on position ax=@(...)... ay=@(...)... %simulate orbit for i=1:steps x(i+1)=... % y(i+1)=... %update position and velocity vx(i+1)=... %using Velocity-Verlet vy(i+1)=... % end %plot and analyse results 14