def main():

    skull = Body.GravBody(5, 6.371 * 10**6, 8000.)
    solver = Solver.RK2(0.001)

    def stop_condition(skull):
        return skull.velocity > 0

    sim1 = Simulation.TrajectorySim(stop_condition, solver, skull)
    x, y = sim1.get_results()
    skull2 = Body.GravBody(5, 6.371 * 10**6, 8000.)
    sim2 = Simulation.InverseTrajectorySim(stop_condition, solver, skull2)
    a, b = sim2.get_results()

    plt.plot(x, y)
    plt.plot(a, b)
    plt.title("Skull Tosses")
    plt.xlabel("Time [s]")
    plt.ylabel("Height [m]")
    plt.legend(["Uniform Gravity", "Inverse Square Gravity"])

    plt.figure()
    varray = np.arange(0, 100, 0.5)
    harray = []
    for v in varray:
        skull3 = Body.GravBody(5, 6.371 * 10**6, v)
        sim3 = Simulation.InverseTrajectorySim(stop_condition, solver, skull3)
        result = sim3.get_results()
        harray.append(skull3.position)

    plt.plot(varray, harray)
    plt.title("Maximum Height vs. Initial Velocity")
    plt.xlabel("Initial Velocity [m/s]")
    plt.ylabel("Maximum Height [m]")
 def sim_1(self):    
     Earth = Body.GravBody(1,self.rEarth,self.vEarth)
     Mars = Body.GravBody(1,self.rMars,self.vMars)
     Planets = [Earth,Mars]
     sim = Simulation.OrbitSim(self.stop_1,self.physics,Planets)
     sim.advance()
     time, bodies = sim.get_results()
     return bodies[-1][1].position.theta
 def __init__(self,solver,stopCondition,physics,Ms,Mp,Rs,Rp,ap,e,omega,i):
     
     self.Rs=Rs
     self.Rp=Rp
     self.omega=omega
     self.i=i
     self.Ms=Ms
     self.Mp=Mp
     self.ap=ap
     self.e=e
     self.physics=physics
     self.desiredOrbitRadius=None
     self.numberOrbits=0
     self.G=6.67408*10**-11
     
     self.vp=math.sqrt(self.G*Ms**3*(1+e)/(ap*(Mp+Ms)**2*(1-e)))
     self.vs=-(Mp/Ms)*self.vp
     self.rp=ap-ap*e
     self.rs=-(Mp/Ms)*self.rp
     
     M=1.989*10**30
     
     body1x=self.rp
     body1y=0
     body1z=0
     body1pos=Vector.Vector(x=body1x,y=body1y,z=body1z)
     body1pos.rotZ(omega)
     body1pos.rotX(i)
     
     body2x=self.rs
     body2y=0
     body2z=0
     body2pos=Vector.Vector(x=body2x,y=body2y,z=body2z)
     body2pos.rotZ(omega)
     body2pos.rotX(i)
     
     body1vx=0
     body1vy=self.vp
     body1vz=0
     body1vel=Vector.Vector(x=body1vx,y=body1vy,z=body1vz)
     body1vel.rotZ(omega)
     body1vel.rotX(i)
     
     body2vx=0
     body2vy=self.vs
     body2vz=0
     body2vel=Vector.Vector(x=body2vx,y=body2vy,z=body2vz)
     body2vel.rotZ(omega)
     body2vel.rotX(i)
     
     self.body1=Body.GravBody(body1vel,body1pos,Mp)
     self.body2=Body.GravBody(body2vel,body2pos,Ms)
     bodies=[self.body1,self.body2]
     
     super(ExoSim,self).__init__(solver,bodies,stopCondition,M)
 def sim_3(self):
     r1 = vector.Vector(1., 0, 0)
     v1 = vector.Vector(0, 1.1 * math.pi, 0)
     r2 = vector.Vector(-1., 0, 0)
     v2 = vector.Vector(0, -1.1 * math.pi, 0)
     One = Body.GravBody(1., r1, v1)
     Two = Body.GravBody(1., r2, v2)
     Objects = [One, Two]
     sim = Simulation.OrbitSim(physics=self.physics, body=Objects)
     sim.advance(time=10.)
     time, bodies = sim.get_results()
     self.plorbits(bodies)
    def angleError(self, phi):
        '''The error function used in a Search method for finding an angle that
        gives an equal max height and distance.
        
        Parameters
        -----
        phi : float
            The angle whose error is being calculated.
            
        Returns
        -----
        float
            The difference between the max height and the distance traveled for
            the given phi.
        '''
        rock = Body.GravBody(Vector.Vector(r=100.,theta=0,phi=phi),Vector.Vector(x=0,y=0,z=0))
        
        rockTrajectory = TrajectorySim(self.solver,rock,Physics.stopCondition,c=self.c)
        t,bodies = rockTrajectory.simulate()
        
        z=[b.position.z for b in bodies]
#        y=[b.position.y for b in bodies]
        x=[b.position.x for b in bodies]
#        print max(z)
#        print x[-1]
#        
#        plt.plot(x,z)
        
        dist=x[-1]
        
        return max(z)-dist
 def vError(self, v):
     '''The error function used in a Search method for finding an initial
     velocity that gives a trajectory that reaches the desired height.
     
     Parameters
     -----
     v : float
         The velocity whose error is being calculated.
         
     Returns
     -----
     float
         The difference between the calculated height and the desired height.
     '''
     step=0.01
     
     skull = Body.GravBody(Vector.Vector(x=0,y=0,z=v),Vector.Vector(x=0,y=0,z=self.startHeight))
     solver = Solver.RK2(step,Physics.UniformGravity.diffEq)
     
     skullFlight = TrajectorySim(solver,Vector.Vector(x=0,y=0,z=self.g),skull,Physics.stopCondition)
     t,bodies = skullFlight.simulate()
     
     hGuess = bodies[-1].position.z
     
     return hGuess-self.desiredHeight  
 def error_3(self,launch_time):
     vShip = vector.Vector(0,2*math.pi,0)
     rShip = vector.Vector(1,0,0)
     Ship = Body.GravBody(1,rShip,vShip)
     rMars = vector.Vector(1.5,0,0)
     vMars = vector.Vector(0,2*math.pi/math.sqrt(1.5),0)
     Mars = Body.GravBody(1,rMars,vMars)
     Objects = [Ship,Mars]
     sim = Simulation.OrbitSim(physics=self.physics,body=Objects)
     sim.advance(time=launch_time)
     sim.body[0].velocity.r = self.vL
     p = ((2.5/2.)**(3./2.))/2.
     sim.advance(time=p+launch_time)
     t2list,blist = sim.get_results()
     sep = sim.body[1].position - sim.body[0].position
     error = sep.r
     if error <= 0.01:
         self.plorbits(blist)
     return error
 def __init__(self,
              Ms=None,
              Mp=None,
              ap=None,
              e=0,
              Rs=None,
              Rp=None,
              omega=None,
              i=None,
              apnd=True):
     '''Save Values'''
     self.apnd = apnd
     self.Rs = Rs
     self.Rp = Rp
     self.G = 4 * math.pi**2.
     self.period = np.sqrt(((ap**3.) * ((Ms + Mp)**2.)) / Ms**3.)
     '''Set up Vectors'''
     rpp = ap - e * ap
     rsp = -(Mp / Ms) * rpp
     vpp = math.sqrt(
         ((self.G * Ms**3.) / (ap * (Ms + Mp)**2.)) * ((1. + e) / (1. - e)))
     vsp = -(Mp / Ms) * vpp
     '''Rotate Vectors into Viewer frame'''
     rs = vector.Vector(rsp, 0., 0.)
     rs.rot_z(omega)
     rs.rot_x(i)
     rp = vector.Vector(rpp, 0., 0.)
     rp.rot_z(omega)
     rp.rot_x(i)
     vs = vector.Vector(0., vsp, 0.)
     vs.rot_z(omega)
     vs.rot_x(i)
     vp = vector.Vector(0., vpp, 0.)
     vp.rot_z(omega)
     vp.rot_x(i)
     '''Set Up Sim'''
     star = Body.GravBody(Ms, rs, vs)
     planet = Body.GravBody(Mp, rp, vp)
     self.body = [star, planet]
     solver = Solver.RK2(0.01)
     self.physics = Physics.NBody(solver, self.G)
     self.bodies = [cp.deepcopy(self.body)]
     self.t = [0]
    def closed2BodyAutoBuilder(omega, i, mBig, mSmall, ap, e):
        """
        """
        G = 1  #6.67408*10**(-11)
        vp = np.sqrt(G * mBig**3 * (1 + e) / (ap * (mSmall + mBig)**2 *
                                              (1 - e)))
        vs = -(mSmall / mBig) * vp
        rp = ap - ap * e
        rs = -(mSmall / mBig) * rp

        body1x = rp
        body1y = 0
        body1z = 0
        body1pos = Vector.Vector(x=body1x, y=body1y, z=body1z)
        body1pos.rotZ(omega)
        body1pos.rotX(i)

        body2x = rs
        body2y = 0
        body2z = 0
        body2pos = Vector.Vector(x=body2x, y=body2y, z=body2z)
        body2pos.rotZ(omega)
        body2pos.rotX(i)

        body1vx = 0
        body1vy = vp
        body1vz = 0
        body1vel = Vector.Vector(x=body1vx, y=body1vy, z=body1vz)
        body1vel.rotZ(omega)
        body1vel.rotX(i)

        body2vx = 0
        body2vy = vs
        body2vz = 0
        body2vel = Vector.Vector(x=body2vx, y=body2vy, z=body2vz)
        body2vel.rotZ(omega)
        body2vel.rotX(i)

        body1 = Body.GravBody(body1vel, body1pos, mSmall)
        body2 = Body.GravBody(body2vel, body2pos, mBig)
        bodies = [body1, body2]

        return bodies
 def findV(self,tolerance):
     '''Finds the velocity given a desired height within a given tolerance
     for a body on Earth.
     
     Parameters
     -----
     tolerance : float
         How close you want to be to the theoretically ideal value.
         
     Returns
     -----
     The estimated velocity.
     '''
     
     desiredHeight=self.desiredHeight
     vGuess=self.vGuess
     hGuess=self.hGuess
     g = -9.81
     step = 0.1 
     lastvGuess = vGuess
     up = False
     down = False
     
     while abs(hGuess-desiredHeight)>tolerance:
         
         skull = Body.GravBody(vGuess,self.startHeight)
         solver = Solver.RK2(step,Physics.UniformGravity.diffEq)
         
         skullFlight = TrajectorySim(solver,g,skull,Physics.stopCondition)
         t,vAndh = skullFlight.simulate()
         
         hGuess = vAndh[1][-1]
         
         if hGuess-desiredHeight < 0:
             up = True
             if down == False:
                 lastvGuess = vGuess
                 vGuess = vGuess*2
             else:
                 lvgHold = vGuess
                 vGuess = vGuess + abs(lastvGuess-vGuess)*0.5
                 lastvGuess = lvgHold
                 
         elif hGuess-desiredHeight > 0:
             down = True
             if up == False:
                 lastvGuess = vGuess
                 vGuess = vGuess/2.
             else:
                 lvgHold = vGuess
                 vGuess = vGuess - abs(vGuess-lastvGuess)*0.5
                 lastvGuess = lvgHold
         else: print('Error?')
     
     return vGuess
    def __init__(self,solver,stopCondition,physics,M1,M2,a1,e):

        self.M1=M1
        self.M2=M2
        self.a1=a1
        self.e=e
        self.physics=physics
        self.desiredOrbitRadius=None
        self.numberOrbits=0
        self.G=6.67408*10**-11
        
        self.v1=math.sqrt(self.G*M2**3*(1+e)/(a1*(M1+M2)**2*(1-e)))
        self.v2=-(M1/M2)*self.v1
        self.r1=a1-a1*e
        self.r2=-(M1/M2)*self.r1
        
        M=1.989*10**30
        
        body1x=self.r1
        body1y=0
        body1z=0
        body1pos=Vector.Vector(x=body1x,y=body1y,z=body1z)
        
        body2x=self.r2
        body2y=0
        body2z=0
        body2pos=Vector.Vector(x=body2x,y=body2y,z=body2z)
        
        body1vx=0
        body1vy=self.v1
        body1vz=0
        body1vel=Vector.Vector(x=body1vx,y=body1vy,z=body1vz)
        
        body2vx=0
        body2vy=self.v2
        body2vz=0
        body2vel=Vector.Vector(x=body2vx,y=body2vy,z=body2vz)
        
        self.body1=Body.GravBody(body1vel,body1pos,M1)
        self.body2=Body.GravBody(body2vel,body2pos,M2)
        bodies=[self.body1,self.body2]
        super(BinarySim,self).__init__(solver,bodies,stopCondition,M)
 def error_2(self,v0):
     vShip = vector.Vector(0,v0,0)
     rShip = vector.Vector(1,0,0)
     Ship = Body.GravBody(1,rShip,vShip)
     sim = Simulation.OrbitSim(self.stop_1,self.physics,Ship)
     sim.advance()
     time, Ships = sim.get_results()
     r = [[s.position.r for s in ship] for ship in Ships]
     max_r = max(r)
     error = max_r[0] - 1.5 #since r becomes another stupid list of lists
     return error
 def __init__(self, M1=None, M2=None, a1=1, e=0, apnd=True):
     '''Build GravBodies'''
     self.G = 4 * math.pi**2.
     r1p = a1 - e * a1
     r2p = -(M1 / M2) * r1p
     v1p = math.sqrt(
         ((self.G * M2**3.) / (a1 * (M1 + M2)**2.)) * ((1. + e) / (1. - e)))
     v2p = -(M1 / M2) * v1p
     r1 = vector.Vector(r1p, 0., 0.)
     r2 = vector.Vector(r2p, 0., 0.)
     v1 = vector.Vector(0., v1p, 0.)
     v2 = vector.Vector(0., v2p, 0.)
     body1 = Body.GravBody(M1, r1, v1)
     body2 = Body.GravBody(M2, r2, v2)
     '''Set up Sim'''
     self.body = [body1, body2]
     solver = Solver.RK2(0.01)
     self.physics = Physics.NBody(solver, self.G)
     self.bodies = [cp.deepcopy(self.body)]
     self.t = [0]
     self.apnd = apnd
 def error(theta):
     htarg = 0
     r =  vector.Vector(0,0,0)
     v = vector.Vector(r=100,theta=theta,phi=(math.pi/2))
     particle = Body.GravBody(5,r,v)
     solver =Solver.RK4(0.1)
     physics = Physics.UniformGravity(solver,c=0.1)
     sim = Simulation.TrajectorySim(stop_maker(htarg),physics,particle)
     a,b = sim.get_results()
     y = [p.position.y for p in b]
     E = particle.position.x - max(y)
     return E
Example #15
0
def main():
    skull = Body.GravBody(5, 5, 5)
    solver = Solver.RK2(0.001)

    def stop_condition(skull):
        return skull.velocity > 0

    sim = Simulation.TrajectorySim(stop_condition, solver, skull)
    t, h = sim.get_results()
    plt.plot(t, h)
    plt.title("OOP Skull Toss")
    plt.xlabel("Time [s]")
    plt.ylabel("Height [m]")
 def manualOrbitBuilder(xPos,yPos,zPos,xVel,yVel,zVel,mass):
     '''
     '''
     
     bodies=[]
     
     for i in range(len(xPos)):
         bodyPos = Vector.Vector(x=xPos[i],y=yPos[i],z=zPos[i])
         bodyVel = Vector.Vector(x=xVel[i],y=yVel[i],z=zVel[i])
         body    = Body.GravBody(bodyVel,bodyPos,mass[i])
         bodies.append(body)
         
     return bodies
         
Example #17
0
 def __init__(self):
     
     '''Build Grav Bodies'''
     ms = 9. 
     sunr = vector.Vector(0.,0.,0.)
     sunv = vector.Vector(0.,-0.6*np.pi/ms,0.)
     self.sun = Body.GravBody(ms,sunr,sunv)
     
     me = 0.1 
     earthr = vector.Vector(1.,0.,0.)
     earthv = vector.Vector(0.,6.*np.pi,0.)
     self.earth = Body.GravBody(me,earthr,earthv)
     
     mr5 = 0.1 
     rigel5r = vector.Vector(5.,0.,0.)
     rigel5v = vector.Vector(0.,2.*np.pi*np.sqrt(me+ms)/np.sqrt(5.),0.)
     self.rigel5 = Body.GravBody(mr5,rigel5r,rigel5v)
     
     '''Build Sim'''
     planets = [self.sun,self.earth,self.rigel5]
     solver = Solver.RK4(0.01)
     physics = Physics.NBody(solver,G=4.*np.pi**2.)
     self.sim = Simulation.OrbitSim(physics=physics,body=planets,apnd=False)
    def __init__(self, pixels_per_AU=None, screen_size=None):

        pg.sprite.Sprite.__init__(self)
        self.pixels_per_AU = pixels_per_AU
        self.screen_size = screen_size
        self.image = pg.image.load('asteroid.png').convert_alpha()
        self.rect = self.image.get_rect()
        '''Create Random GravBodies'''
        mass = 0.0
        index = rand.randint(1, 4)
        if index == 1:
            position = vector.Vector(x=rand.uniform(-6, 6), y=5.99, z=0.0)
            velocity = vector.Vector(r=5 * np.pi,
                                     theta=(rand.uniform(180, 360) * np.pi /
                                            180),
                                     phi=np.pi / 2.)
        if index == 2:
            position = vector.Vector(x=rand.uniform(-6, 6), y=-5.99, z=0.0)
            velocity = vector.Vector(r=5 * np.pi,
                                     theta=(rand.uniform(0, 180) * np.pi /
                                            180),
                                     phi=np.pi / 2.)
        if index == 3:
            position = vector.Vector(x=-5.99, y=rand.uniform(-6, 6), z=0.0)
            velocity = vector.Vector(r=5 * np.pi,
                                     theta=(rand.uniform(270, 450) * np.pi /
                                            180),
                                     phi=np.pi / 2.)
        if index == 4:
            position = vector.Vector(x=5.99, y=rand.uniform(-6, 6), z=0.0)
            velocity = vector.Vector(r=5 * np.pi,
                                     theta=(rand.uniform(90, 270) * np.pi /
                                            180),
                                     phi=np.pi / 2.)
        self.body = Body.GravBody(mass, position, velocity)
        self.update()
Example #19
0
    def run(self):
        '''Orbits'''
        for v0 in self.v0_list:
            for dt in self.dt_list:
                r = vector.Vector(self.AU, 0, 0)  #starting position in AU
                v = vector.Vector(0, v0, 0)
                earth = Body.GravBody(1, r, v)
                solver = Solver.RK4(dt)
                physics = Physics.CentralGravity(solver, G=4 * math.pi**2,
                                                 M=1)  # M is 1 solar mass
                sim = Simulation.OrbitSim(self.stop, physics, earth)
                time, bodies = sim.get_results()

                y = [b[0].position.y for b in bodies]
                x = [b[0].position.x for b in bodies]
                energy = physics.energy(bodies)
                errors = self.error(energy)

                if v0 == math.pi * 2:
                    plt.figure(1)
                    plt.plot(x, y, '.')
                    plt.title("Circular Orbits of Earth Around Sun")
                    plt.ylabel("Position in y [AU]")
                    plt.xlabel("Position in x [AU]")
                    plt.legend(["dt=0.003", "dt=0.002", "dt=0.001"])

                    plt.figure(2)
                    plt.plot(time, errors)
                    plt.title("Error in Energy vs Time")
                    plt.ylabel("Percent Error")
                    plt.xlabel("Time [Years]")
                    plt.legend(["dt=0.003", "dt=0.002", "dt=0.001"])

                else:
                    plt.figure(3)
                    plt.plot(x, y, '.')
                    plt.title("Elliptical Orbits of Earth Around Sun")
                    plt.ylabel("Position in y [AU]")
                    plt.xlabel("Position in x [AU]")
                    plt.legend(["dt=0.003", "dt=0.002", "dt=0.001"])

                    plt.figure(4)
                    plt.plot(time, errors)
                    plt.title("Error in Energy vs Time")
                    plt.ylabel("Percent Error")
                    plt.xlabel("Time [Years]")
                    plt.legend(["dt=0.003", "dt=0.002", "dt=0.001"])
        """Kepler"""
        r_list = [0.9, 1, 1.1]
        v_list = [2 * math.pi, 2 * 0.9 * math.pi, 2 * 1.1 * math.pi]
        for r in r_list:
            for v in v_list:
                r0 = vector.Vector(r, 0, 0)
                v0 = vector.Vector(0, v, 0)
                earth = Body.GravBody(1, r0, v0)
                solver = Solver.RK4(0.001)
                physics = Physics.CentralGravity(solver, G=4 * math.pi**2,
                                                 M=1)  # M is 1 solar mass
                sim = Simulation.OrbitSim(self.stop, physics, earth)
                time, bodies = sim.get_results()
                a = sim.semimajor_axis()
                p = sim.period()
                plt.figure(5)
                plt.plot(a, p, '.')
        plt.figure(5)
        a = np.arange(0, 2, 0.001)
        p = a**(3. / 2.)
        plt.plot(a, p)
        plt.title("Semi Major Axis vs Period")
        plt.ylabel("Orbital Period [Years]")
        plt.xlabel("Semi Major Axis [AU]")