Benutzer-Werkzeuge

Webseiten-Werkzeuge


ss17:viele_dinge_fliegen_im_weltall_durcheinander:testprogramme

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen gezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen Revision Vorhergehende Überarbeitung
Nächste Überarbeitung
Vorhergehende Überarbeitung
ss17:viele_dinge_fliegen_im_weltall_durcheinander:testprogramme [2017/08/23 21:55]
mtoppermann [Testprogramme]
ss17:viele_dinge_fliegen_im_weltall_durcheinander:testprogramme [2017/08/28 15:41] (aktuell)
mtoppermann [Vergleich von Planetenbewegungen mit verschiedenen Methoden]
Zeile 4: Zeile 4:
  
 ===== Vergleich von Planetenbewegungen mit verschiedenen Methoden===== ===== Vergleich von Planetenbewegungen mit verschiedenen Methoden=====
 +
 +In diesem Skript wird die Genauigkeit des Euler-Verfahrens mit dem Leapfrog-Verfahren am Bespiel der Erdbewegung
 +um die Sonne verglichen. Die Bewegung der dunkelblauen Erde wir durch das Leapfrog-Verfahren berechnet, das der hellblauen durch das Euler-Verfahren. Nach einiger Zeit sieht man bereits deutliche Unterschiede in der Bahnbewegung:​ Die dunkelblaue Erde verlässt die richtige Bahn langsamer, da ihre die Berechnungsfehler kleiner sind.
  
 <code python> <code python>
 from functions import * from functions import *
 import pygame import pygame
 + 
 class Sun(object):​ class Sun(object):​
-    """​Our Sun in the point of origin + 
-    """​+
     def __init__(self):​     def __init__(self):​
 +        """​initialize all necessary properties of the sun
 +        """​
         self.x = 0         self.x = 0
         self.y = 0         self.y = 0
         self.radius = 20         self.radius = 20
         self.mass = 1.989e30         self.mass = 1.989e30
-        self.colour = (255,​255,​0) +        self.colour = (255, 255, 0) 
 + 
 class Earth(object):​ class Earth(object):​
-    """​Our home +  
-    """​ +    def __init__(self,​ color): 
-    def __init__(self,​color):​+        """​initialize all necessary properties of the earth 
 +        """​
         self.x = 1.49e11         self.x = 1.49e11
         self.y = 0.         self.y = 0.
         self.radius = 10         self.radius = 10
         self.mass = 5.97e24         self.mass = 5.97e24
-        self.velocity = np.array([0.,​2.978e4]) +        self.velocity = np.array([0.,​ 2.978e4]) 
-        self.force = np.array([0,​0])+        self.force = np.array([0,​ 0])
         self.colour = (color)         self.colour = (color)
-        self.positions = [(int(self.x * 1e-9 + width/2), + 
-        int(self.y * 1e-9 + height/​2))] +
- +
-    # leapfrog method for DE-solving+
     def move(self):     def move(self):
 +        """​leapfrog method for differential-equation-solving
 +        """​
         self.x += 0.5 * self.velocity[0] * dt         self.x += 0.5 * self.velocity[0] * dt
         self.y +=  0.5 * self.velocity[1] * dt         self.y +=  0.5 * self.velocity[1] * dt
Zeile 40: Zeile 44:
         self.x += 0.5 * self.velocity[0] * dt         self.x += 0.5 * self.velocity[0] * dt
         self.y +=  0.5 * self.velocity[1] * dt         self.y +=  0.5 * self.velocity[1] * dt
- + 
-    # euler method for DE-solving+
     def move2(self):​     def move2(self):​
 +        """​euler-method for differential-equation-solving
 +        """​
         self.x += self.velocity[0] * dt         self.x += self.velocity[0] * dt
         self.y += self.velocity[1] * dt         self.y += self.velocity[1] * dt
         self.velocity += self.force/​self.mass * dt         self.velocity += self.force/​self.mass * dt
 + 
 def draw(a, points): def draw(a, points):
-    """​Draws an object ​and its trail on the screen+    """​Draws an object on the screen
     """​     """​
     pygame.draw.circle(screen,​ a.colour, (int(a.x * 10e-10) + width/2,     pygame.draw.circle(screen,​ a.colour, (int(a.x * 10e-10) + width/2,
     int(a.y * 10e-10) + height/2), a.radius, 0)     int(a.y * 10e-10) + height/2), a.radius, 0)
     pygame.draw.aalines(screen,​ a.colour, False, points, 2)     pygame.draw.aalines(screen,​ a.colour, False, points, 2)
 + 
 def draw2(a): def draw2(a):
     """​Draws an object in the middle of the screen     """​Draws an object in the middle of the screen
     """​     """​
     pygame.draw.circle(screen,​ a.colour, (width/2, height/2), a.radius, 0)     pygame.draw.circle(screen,​ a.colour, (width/2, height/2), a.radius, 0)
- + 
-def last_elems(elems,​ k): +
-    """​Returns the last k elements of a list +
-    """​ +
-    tmp = [] +
-    for i in xrange(k):​ +
-        if i > len(elems):​ +
-            break +
-        elif i < len(elems):​ +
-            tmp.append(elems[-(i+1)]) +
-    return tmp +
 dt = 36000 dt = 36000
-(width, height) = (1000,600)+(width, height) = (1000, 600)
 screen = pygame.display.set_mode((width,​ height)) screen = pygame.display.set_mode((width,​ height))
 pygame.display.set_caption("​ ") pygame.display.set_caption("​ ")
-background_colour ​= (10,​10,​10) +bgcolour ​= (10, 10, 10) 
- +  
-earth = Earth((0,​0,​255)) +earth = Earth((0, 0, 255)) 
-kerbin = Earth((50,​150,​255)) +kerbin = Earth((50, 150, 255)) 
-sonne = Sun() +sun = Sun() 
- + 
-count = 0+
 running = True running = True
 while running: while running:
Zeile 86: Zeile 79:
         if event.type == pygame.QUIT:​         if event.type == pygame.QUIT:​
             running = False             running = False
- + 
-    #every ten steps, the trail is updated +
-    if count % 10 == 0: +
-        erde.positions.append((int(1e-9 * erde.x) + width/2, +
-        int(1e-9 * erde.y) + height/​2)) +
-        kerbin.positions.append((int(1e-9 * kerbin.x) + width/2, +
-        int(1e-9 * kerbin.y) + height/​2)) +
-        linepoints1 = last_elems(erde.positions,​ 200) +
-        linepoints2 = last_elems(kerbin.positions,​ 200) +
     # display everything     # display everything
-    screen.fill(background_colour)+    screen.fill(bgcolour)
     draw(erde, linepoints1)     draw(erde, linepoints1)
     draw(kerbin,​ linepoints2)     draw(kerbin,​ linepoints2)
     draw2(sonne)     draw2(sonne)
     pygame.display.update()     pygame.display.update()
 + 
     # calculate everything     # calculate everything
-    erde.force = get_force(erdesonne+    erde.force = get_force(earthsun
-    kerbin.force = get_force(kerbin, ​sonne)+    kerbin.force = get_force(kerbin, ​sun)
     erde.move()     erde.move()
     kerbin.move2()     kerbin.move2()
- + 
-    count += 1   +
  </​code>​  </​code>​
- 
 =====Euler-Verfahren vs Verlet(Leapfrog)-Verfahren===== =====Euler-Verfahren vs Verlet(Leapfrog)-Verfahren=====
  
ss17/viele_dinge_fliegen_im_weltall_durcheinander/testprogramme.1503518107.txt.gz · Zuletzt geändert: 2017/08/23 21:55 von mtoppermann