Exemplo n.º 1
0
def threebody(id, r, v, t):         # Eqns of motion for 3-body
    if (id==0): return v            # return velocity array
    else:                           # calc acceleration
        r12, r13, r23 = r[0]-r[1], r[0]-r[2], r[1]-r[2]
        s12, s13, s23 = vp.mag(r12), vp.mag(r13), vp.mag(r23)
        a = [-m2*r12/s12**3 - m3*r13/s13**3,        # $\frac{d\vec{v}_i}{dt}$, 
              m1*r12/s12**3 - m3*r23/s23**3,
              m1*r13/s13**3 + m2*r23/s23**3]
        return np.array(a)          # return accel array
Exemplo n.º 2
0
def threebody(id, r, v, t):  # Eqns of motion for 3-body
    if (id == 0): return v  # return velocity array
    else:  # calc acceleration
        r12, r13, r23 = r[0] - r[1], r[0] - r[2], r[1] - r[2]
        s12, s13, s23 = vp.mag(r12), vp.mag(r13), vp.mag(r23)
        a = [
            -m2 * r12 / s12**3 -
            m3 * r13 / s13**3,  # $\frac{d\vec{v}_i}{dt}$, 
            m1 * r12 / s12**3 - m3 * r23 / s23**3,
            m1 * r13 / s13**3 + m2 * r23 / s23**3
        ]
        return np.array(a)  # return accel array
 def c_acel(self, xm, obj):
     acel = v.vector(0, 0, 0)
     for i in obj:
         if i.id != self.id:
             acel += (i.mass * (v.norm(i.pos - xm) * G) /
                      (v.mag(i.pos - xm)**2))
     return acel
Exemplo n.º 4
0
def calculateVelocities(k1, k2):
    a=vs.mag((k1.vel-k2.vel)**2.0)
    b=-2.*np.dot((k1.pos-k2.pos),(k1.vel-k2.vel))
    c=vs.mag(np.power(k1.pos-k2.pos,2.)-np.power(k1.radius+k2.radius,2.))
    delta=b**2.0-4.0*a*c
    if a == 0. or delta < 0.:
        return
    dtp=(-1.0*b+np.sqrt(delta))/(2.*a)
    k1.pos-=k1.vel*dtp
    k2.pos-=k2.vel*dtp
    wsp=(k1.pos-k2.pos)/(np.abs(vs.mag(k1.pos-k2.pos)))
    k1.vel=k1.vel-2.0* k2.m /(k1.m+k2.m)*np.dot(k1.vel-k2.vel,wsp)*wsp
    k2.vel=k2.vel+2.0* k2.m /(k1.m+k2.m)*np.dot(k1.vel-k2.vel,wsp)*wsp
    k1.pos+=k1.vel*dtp
    k2.pos+=k2.vel*dtp
    print("hura")
Exemplo n.º 5
0
def reDrawLines():
    global fwd_line, mouse_line, cam_dist, ray, scene_size, linelen
    linelen = scene_size + vs.mag(cam_frame.axis.norm() * cam_dist +
                                  cam_frame.pos)
    reDrawLine(fwd_line, vs.vector(cam_dist, 0, 0), linelen,
               vs.vector(-1, 0, 0))
    reDrawLine(mouse_line, vs.vector(cam_dist, 0, 0), linelen, ray)
Exemplo n.º 6
0
def getfield(posn):
    """ Get the field at a given point."""
    fld = vp.vector(0, 0, 0)
    for chrg in CHARGES:
        fld = fld + (posn - chrg.pos) * 8.988e9 * chrg.Q / vp.mag(posn -
                                                                  chrg.pos)**3
    return fld
Exemplo n.º 7
0
def drawCameraFrame():  # create frame and draw its contents
    global  cam_box, cent_plane,  cam_lab, cam_tri, range_lab, linelen, fwd_line
    global fwd_arrow, mouse_line, mouse_arrow, mouse_lab, fov, range_x, cam_dist, cam_frame
    global ray
    cam_frame = vs.frame( pos = vs.vector(0,2,2,),  axis = (0,0,1))
               # NB: contents are rel to this frame.  start with camera looking "forward"
               # origin is at simulated scene.center
    fov = vs.pi/3.0  # 60 deg 
    range_x = 6  # simulates scene.range.x  
    cam_dist = range_x / vs.tan(fov/2.0)  # distance between camera and center. 
    ray = vs.vector(-20.0, 2.5, 3.0).norm()  # (unit) direction of ray vector (arbitrary)
                                         #  REL TO CAMERA FRAME
    cam_box = vs.box(frame=cam_frame, length=1.5, height=1, width=1.0, color=clr.blue,
                                                   pos=(cam_dist,0,0)) # camera-box
    cent_plane = vs.box(frame=cam_frame, length=0.01, height=range_x*1.3, width=range_x*2,
                                                    pos=(0,0,0), opacity=0.5 )  # central plane
    cam_lab = vs.label(frame=cam_frame, text= 'U', pos= (cam_dist,0,0), height= 9, xoffset= 6)
    cam_tri = vs.faces( frame=cam_frame, pos=[(0,0,0), (0,0,-range_x), (cam_dist,0,0)])
    cam_tri.make_normals()
    cam_tri.make_twosided()
    range_lab = vs.label(frame=cam_frame, text= 'R', pos= (0, 0, -range_x), height= 9, xoffset= 6)
    linelen = scene_size + vs.mag( cam_frame.axis.norm()*cam_dist + cam_frame.pos)
                                                                   # len of lines from camera
    fwd_line = drawLine( vs.vector(cam_dist,0,0), linelen, vs.vector(-1,0,0))
    fwd_arrow = vs.arrow(frame=cam_frame, axis=(-2,0,0), pos=(cam_dist, 0, 0), shaftwidth=0.08,
                                                                            color=clr.yellow)
    vs.label(frame=cam_frame, text='C', pos=(0,0,0), height=9, xoffset=6, color=clr.yellow)
    mouse_line = drawLine ( vs.vector(cam_dist,0,0), linelen, ray ) 
    mouse_arrow = vs.arrow(frame=cam_frame, axis=ray*2, pos=(cam_dist,0,0), shaftwidth=0.08,
                                                                                   color=clr.red)
    mouse_lab = vs.label(frame=cam_frame, text= 'M', height= 9, xoffset= 10, color=clr.red, 
                                pos=  -ray*(cam_dist/vs.dot(ray,(1,0,0))) + (cam_dist,0,0))
Exemplo n.º 8
0
def calculateVelocities(k1, k2):
    a = vs.mag((k1.vel - k2.vel)**2.0)
    b = -2. * np.dot((k1.pos - k2.pos), (k1.vel - k2.vel))
    c = vs.mag(
        np.power(k1.pos - k2.pos, 2.) - np.power(k1.radius + k2.radius, 2.))
    delta = b**2.0 - 4.0 * a * c
    if a == 0. or delta < 0.:
        return
    dtp = (-1.0 * b + np.sqrt(delta)) / (2. * a)
    k1.pos -= k1.vel * dtp
    k2.pos -= k2.vel * dtp
    wsp = (k1.pos - k2.pos) / (np.abs(vs.mag(k1.pos - k2.pos)))
    k1.vel = k1.vel - 2.0 * k2.m / (k1.m + k2.m) * np.dot(
        k1.vel - k2.vel, wsp) * wsp
    k2.vel = k2.vel + 2.0 * k2.m / (k1.m + k2.m) * np.dot(
        k1.vel - k2.vel, wsp) * wsp
    k1.pos += k1.vel * dtp
    k2.pos += k2.vel * dtp
    print("hura")
def rotation_matrix(omega):
    theta = mag(omega)
    if theta == 0:
        return np.matrix(np.identity(3))
    axis = norm(omega)
    a = cos(theta / 2)
    b, c, d = -axis * sin(theta / 2)
    aa, bb, cc, dd = a * a, b * b, c * c, d * d
    bc, ad, ac, ab, bd, cd = b * c, a * d, a * c, a * b, b * d, c * d
    return np.matrix([[aa+bb-cc-dd, 2*(bc+ad), 2*(bd-ac)],
                      [2*(bc-ad), aa+cc-bb-dd, 2*(cd+ab)],
                      [2*(bd+ac), 2*(cd-ab), aa+dd-bb-cc]])
Exemplo n.º 10
0
def go(animate=True):  # default: True
    r, v = np.array([0.4667, 0.0]), np.array([0.0, 8.198])  # init r, v
    t, h, ta, angle = 0.0, 0.002, [], []
    w = 1.0 / vp.mag(r)  # $W_0=\Omega(r)$

    if (animate): planet, info, RLvec = set_scene(r)
    while t < 100:  # run for 100 years
        L = vp.cross(r, v)  # $\vec{L}/m=\vec{r}\times \vec{v}$
        A = vp.cross(v, L) - GM * r / vp.mag(r)  # scaled RL vec,
        ta.append(t)
        angle.append(np.arctan(A.y / A.x) * 180 * 3600 / np.pi)  # arcseconds
        if (animate):
            vp.rate(100)
            planet.pos = r  # move planet
            RLvec.axis, RLvec.length = A, .25  # update RL vec
            info.text = 'Angle": %8.2f' % (angle[-1])  # angle info
        r, v, t, w = ode.leapfrog_tt(mercury, r, v, t, w, h)

    plt.figure()  # make plot
    plt.plot(ta, angle)
    plt.xlabel('Time (year)'), plt.ylabel('Precession (arcsec)')
    plt.show()
Exemplo n.º 11
0
def mag_gravity(a, b):
    '''Magnitude of gravity between a and b. Since gravity is always
    attractive we can easily calculuate the force on a with norm(b -
    a) and symmetrically for b

    '''

    G = -6.67 * 1e-11
    dist = mag(a.pos - b.pos)**2
    if dist == 0:
        return 0 # The objects were the same
    else:
        return (G * a.mass * b.mass) / (1.0 * dist)
Exemplo n.º 12
0
def go(animate = True):                     # default: True
    r, v = np.array([0.4667, 0.0]), np.array([0.0, 8.198]) # init r, v
    t, h, ta, angle = 0.0, 0.002, [], []
    w = 1.0/vp.mag(r)                       # $W_0=\Omega(r)$
    
    if (animate): planet, info, RLvec = set_scene(r)
    while t<100:                            # run for 100 years
        L = vp.cross(r, v)                  # $\vec{L}/m=\vec{r}\times \vec{v}$
        A = vp.cross(v, L) - GM*r/vp.mag(r) # scaled RL vec, 
        ta.append(t)
        angle.append(np.arctan(A.y/A.x)*180*3600/np.pi) # arcseconds
        if (animate):    
            vp.rate(100)   
            planet.pos = r                              # move planet
            RLvec.axis, RLvec.length = A, .25           # update RL vec
            info.text='Angle": %8.2f' %(angle[-1])      # angle info 
        r, v, t, w = ode.leapfrog_tt(mercury, r, v, t, w, h)
        
    plt.figure()        # make plot
    plt.plot(ta, angle)
    plt.xlabel('Time (year)'), plt.ylabel('Precession (arcsec)')
    plt.show()
Exemplo n.º 13
0
def run_3body(scale):
    t, h, ic, cycle, R = 0.0, 0.001, 0, 20, 0.1  # anim cycle, R=obj size
    r, v = init_cond(scale)
    body, vel, line = set_scene(R, r)  # create objects
    while True:
        vp.rate(1000)
        r, v = ode.leapfrog(threebody, r, v, t, h)
        ic = ic + 1
        if (ic % cycle == 0):  # animate once per 'cycle'
            for i in range(3):  # move bodies, draw vel, path, lines
                body[i].pos = r[i]  # bodies
                vel[i].pos, vel[i].axis = body[i].pos, v[i]
                vel[i].length = R * (1 + 2 * vp.mag(v[i]))  # scale vel vector
            line.pos = [body[i].pos for i in [0, 1, 2]]  # lines
Exemplo n.º 14
0
def run_3body(scale):
    t, h, ic, cycle, R = 0.0, 0.001, 0, 20, 0.1 # anim cycle, R=obj size
    r, v = init_cond(scale)
    body, vel, line = set_scene(R, r)     # create objects
    while True:
        vp.rate(1000)
        r, v = ode.leapfrog(threebody, r, v, t, h)
        ic = ic + 1
        if (ic % cycle == 0):       # animate once per 'cycle'
            for i in range(3):      # move bodies, draw vel, path, lines
                body[i].pos = r[i]  # bodies 
                vel[i].pos, vel[i].axis = body[i].pos, v[i]
                vel[i].length = R*(1+2*vp.mag(v[i]))    # scale vel vector
            line.pos = [body[i].pos for i in [0,1,2]]   # lines  
Exemplo n.º 15
0
 def __compute_sin_cos_beta(self):
     '''
     find cos_beta and sin_beta from velocity vector 
     where beta is the angle between x plane and velocity vector
     '''
     v0_length = mag(self.velocities[-1])
     eps = 0.00001
     
     if(v0_length<=eps):
         cos_beta=0.0
         sin_beta=1.0
     else:
         cos_beta =  self.velocities[-1][0]/v0_length
         sin_beta = self.velocities[-1][1]/v0_length
     return sin_beta, cos_beta
def solver(t, x0, v0, sin_beta, cos_beta, alfa, mi, k1, k2, m, sign_omega, kappa=1/20.0, B=4):
    '''
    Solves the move equation. Move happens on an inclined plane with 
    rules of uniformly accelerated motion.
    Air resistance force is dependent with velocity, friction is constant.
    Arguments:
        x0: initial position - vector
        v0: initial velocity in m/s - vector
        cos_beta,sin_beta - beta is the angle between x plane and velocity vector
        t: time - list of discrete time samples to be considered e.g. np.linspace(0, 5, 21)
        alfa: slope degree (degree between  B and C)
           |\     
           |  \
        A  |    \  C
           | alfa \
           |________\
               B   
        mi: coefficient of friction       
        k1: air drag factor
        k2: air drag 
        m : skier mass in kg
        kappa: curvature - reciprocal of the radius (positive makes right turn)
        B : boundary value (in m/s) from with air drag becomes 
                proportional to the square of the velocity.
    '''

    '''
    Air drag is proportional to the square of velocity
    when the velocity is grater than some boundary value: B.
    k1 and k2 factors control whether we take square or linear proportion
    '''
    v0_length = mag(v0)
    if v0_length <= B:
        k2 = 0
    else:
        k1 = 0
    
    params = [alfa, mi, k1, k2, m, kappa, cos_beta, sin_beta, sign_omega]
      
    w = odeint(_vectorfield, [x0[0], x0[1], v0[0], v0[1]], t, args=(params,) )
    
    #print w,"\t" #,t,"\t"
    
    wlist = w.tolist()
    y = [wlist[1][1],wlist[1][3]]
    x = [wlist[1][0],wlist[1][2]]

    return x,y
Exemplo n.º 17
0
 def tagToggle2(self):
     # Selecting arrows, and other objects for which "pick" does not work
     closest = 1e9
     closestObj = None
     # Iterate through all objects, and select the closest arrow object.
     for obj in self._otherObjects:
         # only select arrows - other objects can be directly selected.
         if not isinstance(obj, visual.primitives.arrow): continue
         # If this object is closest to pointer, save it for later.
         displacement = visual.mag(self.scene.mouse.pickpos - obj.pos)
         if displacement < closest:
             closest = displacement
             closestObj = obj
     # Now set the tags like normal
     obj = closestObj
     if obj == None: return
     self.tagToggle(obj=obj)
Exemplo n.º 18
0
    def handleCollision(self, other):
        difference = other.p - self.p
        if mag(difference) < self.radius + other.radius:
            vrelative = other.v - self.v
            normal = norm(difference)
            vrn = dot(vrelative, normal)
            if vrn < 0:
                #Collision Detected!
                difference = norm(difference)

                #Compute magnitude of Impulse
                Imag = -(1 + restitution) * vrn / (1.0 / self.mass +
                                                   1.0 / other.mass)

                I = Imag * normal  # convert to a vector

                #Apply impulse to both affected balls
                self.v -= I / self.mass
                other.v += I / other.mass
def _vectorfield(w, t, params):
    '''
    Right hand side of the differential equation in x plane.
    
    d2x/dt2 = v**2*sinus(beta)*kappa - ( mi*g*cos(alfa) + k1*(dx/dt)/m - k2*(dx/dt)^2/m )*cos(beta) 
    
     '''
    _,_, vx, vy  = w
    
    alfa, mi, k1, k2, m, kappa, cosinus, sinus, sign_omega  = params
    vl = mag((vx,vy))
    
    f_R = vl**2*abs(kappa)
    # it's not the valu of the force -> no mass in eq
    f_r = f_R + sign_omega*g*sin(alfa)*cosinus
    
    '''
    f_r can't be negative because it has to have the same sense (colloquially direction) 
    as the f_R. 
    If it is negative we decided to zero the F_R value so the skier goes straight.    
    '''
    if f_r < 0:
        f_r = sign_omega*g*sin(alfa)*cosinus
        f_R = 0
    
     
    '''
    The pressing force is the composition of the centripetal force 
    and component of the gravity force.
    '''
    N = sqrt ( (g*cos(alfa))**2 + (f_R)**2 )
    
    f = [vx,
         vy,                                     # dx/dt
         f_r*sinus*sign_omega
         - (mi*N + k1/m*vl + k2/m*vl**2)*cosinus
         ,
         g*sin(alfa) - f_r*cosinus*sign_omega
         - (mi*N + k1/m*vl + k2/m*vl**2)*sinus                                     # dx/dt
         ]    # dv/dt
    return f
Exemplo n.º 20
0
def draw_camera_frame():
    """Create frame and draw its contents."""
    global  CAM_BOX, CENT_PLANE, CAM_LAB, CAN_TRI, RANGE_LAB, LINELEN, FWD_LINE
    global FWR_ARROW, MOUSE_LINE, MOUSE_ARROW, MOUSE_LAB, FOV, RANGE_X, CAM_DIST, CAM_FRAME
    global RAY
    CAM_FRAME = vs.frame(pos=vs.vector(0, 2, 2, ), axis=(0, 0, 1))
               # NB: contents are rel to this frame.  start with camera looking "forward"
               # origin is at simulated scene.center
    FOV = vs.pi/3.0  # 60 deg
    RANGE_X = 6  # simulates scene.range.x
    CAM_DIST = RANGE_X / vs.tan(FOV/2.0)  # distance between camera and center.
    RAY = vs.vector(-20.0, 2.5, 3.0).norm()  # (unit) direction of ray vector (arbitrary)
                                         #  REL TO CAMERA FRAME
    CAM_BOX = vs.box(frame=CAM_FRAME, length=1.5, height=1, width=1.0,
                     color=CLR.blue, pos=(CAM_DIST, 0, 0)) # camera-box
    CENT_PLANE = vs.box(frame=CAM_FRAME, length=0.01, height=RANGE_X*1.3,
                        width=RANGE_X*2, pos=(0, 0, 0), opacity=0.5)  # central plane
    CAM_LAB = vs.label(frame=CAM_FRAME, text='U', pos=(CAM_DIST, 0, 0),
                       height=9, xoffset=6)
    CAN_TRI = vs.faces(frame=CAM_FRAME, pos=[
        (0, 0, 0), (0, 0, -RANGE_X), (CAM_DIST, 0, 0)])
    CAN_TRI.make_normals()
    CAN_TRI.make_twosided()
    RANGE_LAB = vs.label(frame=CAM_FRAME, text='R', pos=(0, 0, -RANGE_X),
                         height=9, xoffset=6)
    LINELEN = SCENE_SIZE + vs.mag(
        CAM_FRAME.axis.norm()*CAM_DIST + CAM_FRAME.pos)  # len of lines from camera

    FWD_LINE = draw_line(vs.vector(CAM_DIST, 0, 0), LINELEN, vs.vector(-1, 0, 0))
    FWR_ARROW = vs.arrow(frame=CAM_FRAME, axis=(-2, 0, 0), pos=(CAM_DIST, 0, 0),
                         shaftwidth=0.08, color=CLR.yellow)
    vs.label(frame=CAM_FRAME, text='C', pos=(0, 0, 0), height=9, xoffset=6,
             color=CLR.yellow)
    MOUSE_LINE = draw_line(vs.vector(CAM_DIST, 0, 0), LINELEN, RAY)
    MOUSE_ARROW = vs.arrow(frame=CAM_FRAME, axis=RAY*2, pos=(CAM_DIST, 0, 0),
                           shaftwidth=0.08, color=CLR.red)
    MOUSE_LAB = vs.label(
        frame=CAM_FRAME, text='M', height=9, xoffset=10,
        color=CLR.red,
        pos=-RAY*(CAM_DIST/vs.dot(RAY, (1, 0, 0))) + (CAM_DIST, 0, 0))
Exemplo n.º 21
0
def all_sums_comb(vecs):
    vecs_segs = [] 
    res = 2 
    for v in vecs:
        norm = visual.mag(v)
        v1 = v*(res/norm)
        segs = [] 
        nn = int(norm/res)
        start = 0 
        if not is_span_positive:
            start = -nn
        for i in range(start,nn):
            segs += [v1*i]
        vecs_segs += [segs]
    cartecians = ordered_cartesian(vecs_segs)
    sums = [] 
    for c in cartecians:
        sum = visual.vector(orig)
        for v in c:
            sum += v 
        sums += [sum] 
    return sums     
Exemplo n.º 22
0
def all_sums_comb(vecs):
    vecs_segs = []
    res = 2
    for v in vecs:
        norm = visual.mag(v)
        v1 = v * (res / norm)
        segs = []
        nn = int(norm / res)
        start = 0
        if not is_span_positive:
            start = -nn
        for i in range(start, nn):
            segs += [v1 * i]
        vecs_segs += [segs]
    cartecians = ordered_cartesian(vecs_segs)
    sums = []
    for c in cartecians:
        sum = visual.vector(orig)
        for v in c:
            sum += v
        sums += [sum]
    return sums
Exemplo n.º 23
0
    trail = vp.curve(pos=(0,0,0), radius=0.04)
    ideal = vp.curve(pos=(0,0,0), radius=0.04, color=vp.color.green)
    spin = vp.arrow(axis=omega,pos=(0,0,0),length=1)   # omega dir
    info = vp.label(pos=(1.1*R,2,-2),text='Any key=repeat')
    return scene, ball, trail, ideal, spin
    
def go(x, y, vx, vy):       # motion with full drag and spin effects
    h, t, Y = 0.01, 0., np.array([[x,y,0.], [vx,vy,0.]])  # initialize
    while (Y[0,0]<R and Y[0,1]>0.2):    # before homeplate&above ground
        vp.rate(40)
        t, Y = t+h, ode.RK4(baseball, Y, t, h)  # integrate
        ball.pos, spin.pos = Y[0], Y[0]-offset # move ball, arrow 
        spin.rotate(angle=phi), ball.rotate(angle=phi,axis=omega)  #spin
        trail.append(pos=ball.pos)
        ideal.append(pos=(x+vx*t, y+vy*t-0.5*g*t*t, 0.))  # ideal case
    while (not scene.kb.keys):              # check for key press 
        vp.rate(40)
        spin.rotate(angle=phi), ball.rotate(angle=phi,axis=omega)
    scene.kb.getkey()                       # clear key 
    trail.append(pos=(0,0,0), retain=0)     # reset trails 
    ideal.append(pos=(0,0,0), retain=0)

g, b2, alpha, mass = 9.8, .0013, 5e-5, .15  # parameters    
R, omega = 18.4, 200.*np.array([0,1,1])     # range, angular velocity 
phi, offset = np.pi/16., 0.4*omega/vp.mag(omega)

scene, ball, trail, ideal, spin = set_scene(R)
while (1):
    go(x=0., y=2., vx=30., vy=0.)           # initially z=0, vz=0

Exemplo n.º 24
0
PS = 5.5
DLT = 0.05
THK = 5.04
nl = 1  # nl = 100
CF = vp.frame(frame=ROTOR_FRAME, pos=(0, 0, THK / 2.0 + C1 / 2.0))
for i in range(nl):
    # Extrude rotor core profile to get the full core body
    GE3 = vp.extrusion(
        pos=[(0, 0, i * DLT), (0, 0, i * DLT + THK)], shape=G3, color=(0.7, 0.7, 0.705), twist=0.0, frame=CF
    )

# Do the core wire windings
# Here is a trick to build a saw-teeth profile, to represent many single windings
N = 20  # coils
VRIGHT = vp.vector(0.3, 1.3)
R = vp.mag(VRIGHT) / (2 * N)
VRIGHT = vp.norm(VRIGHT)
# S is the cross sectional profile of "winding block"
S = vp.Polygon([(-0.1, -0.65), (0, -0.65), (0.3, 0.65), (-0.1, 0.65)])
for n in range(N):
    RIGHT = vp.vector(0, -0.65) + (R + n * 2 * R) * VRIGHT
    # Add saw-teeth on the block to represent wires
    S += vp.shapes.circle(pos=(RIGHT.x, RIGHT.y), radius=R, np=4)

# Define the winding path as a rounded rectangle
P = vp.shapes.rectangle(width=0.5, height=THK)
P += vp.shapes.circle(pos=(0, -THK / 2), radius=0.25, np=10)
P += vp.shapes.circle(pos=(0, +THK / 2), radius=0.25, np=10)
WRFS = []
for i in range(NS):
    # We need a separate frame for individiual winding section
Exemplo n.º 25
0
target = V.sphere(pos=(D, H, 0), radius=1, color=V.color.yellow)
target.velocity = V.vector(0, 0, 0)

# The 'dart gun' is just a cylinder.
gun = V.cylinder(pos=(0, 0, 0),
                 axis=gun_len * sight,
                 radius=1,
                 color=V.color.green)

# Run simulation

print 'Starting simulation...'

# Put a little delay to give all the OpenGL stuff time to initialize nicely.
time.sleep(1)

while (arrow.y >= 0 and target.y >=0) and \
          V.mag(arrow.pos-target.pos) > impact_distance:

    V.rate(75)

    for obj in (arrow, target):
        obj.pos += obj.velocity * dt
        obj.velocity += dv

# Report to user.
if V.mag(arrow.pos - target.pos) <= impact_distance:
    print 'Hit!'
else:
    print 'Miss...'
Exemplo n.º 26
0
    k1.pos+=k1.vel*dtp
    k2.pos+=k2.vel*dtp
    print("hura")




n = 20
r = 1.
dt = 0.1
kule = []
scena = vs.display(width=550,height=550)
vs.sphere(pos=(0, 0, 0), radius=20,opacity=0.1)
for x in range(n):
    kula = vs.sphere(pos=np.random.randint(-5,5,3), radius=r)
    kula.m=1.
    kula.vel = np.random.randint(-5,5,3)
    kule.append(kula)

while True:
    vs.rate(10)
    for k1 in kule:
        for k2 in kule:
            k1.pos += k1.vel * dt
            if np.abs(vs.mag(k1.pos - k2.pos)) <= 3.0 * r:

                calculateVelocities(k1, k2)
            if np.abs(vs.mag(k1.pos)) > 20.:
                k1.vel = -k1.vel

Exemplo n.º 27
0
    BAND.p[:, 1] = BAND.p[:, 1] - M * G * DT

    # force[n] is the force on point n from point n+1 (to the right):
    LENGTH = (BAND.pos[1:] - BAND.pos[:-1])
    DIST = vp.sqrt(vp.sum(LENGTH*LENGTH, -1))
    FORCE = K * (DIST - RESTLENGTH)
    FORCE = LENGTH/DIST[:, vp.newaxis] * FORCE[:, vp.newaxis]

    BAND.p[:-1] = BAND.p[:-1] + FORCE*DT
    BAND.p[1:] = BAND.p[1:] - FORCE*DT

    # color based on "stretch":  blue -> white -> red
    C = vp.clip(DIST/RESTLENGTH * 0.5, 0, 2)

    #   blue (compressed) -> white (relaxed) -> red (tension)
    BAND.red[1:] = vp.where(vp.less(C, 1), C, 1)
    BAND.green[1:] = vp.where(vp.less(C, 1), C, 2-C)
    BAND.blue[1:] = vp.where(vp.less(C, 1), 1, 2-C)

    for S in SPHERES:
        DIST = vp.mag(BAND.pos - S.pos)[:, vp.newaxis]
        inside = vp.less(DIST, S.radius)
        if vp.sometrue(inside):
            R = (BAND.pos - S.pos) / DIST
            surface = S.pos + (S.radius)*R

            BAND.pos = surface*inside + BAND.pos*(1-inside)

            pdotR = vp.sum(vp.asarray(BAND.p)*vp.asarray(R), -1)
            BAND.p = BAND.p - R*pdotR[:, vp.newaxis]*inside
Exemplo n.º 28
0
def moment(point, end1, end2=vector(0, 0, 0)):
    '''Returns the moment defined as the distance between a point 
    and a line formed by two endpoints, end1 and end2.
    All points must be given as 3d vectors'''
    return mag(cross(point - end2, point - end1)) /     \
           mag(end1 - end2)
Exemplo n.º 29
0
def hockey(Y, t):               # return eqn of motion
    accel = 0.
    for i in range(len(loc)):
        accel += Q[i]*(Y[0]-loc[i])/(vp.mag(Y[0]-loc[i]))**3
    return [Y[1], q*accel]      # list for non-vectorized solver
Exemplo n.º 30
0
def earth(id, r, v, t):            # return the eqns of motion
    if (id == 0): return v         # velocity, dr/dt
    s = vp.mag(r)                  # $s=|\vec{r}|$
    return -GM*r/(s*s*s)           # accel dv/dt, faster than s**3  
Exemplo n.º 31
0
def reDrawLines():
   global fwd_line, mouse_line, cam_dist, ray, scene_size, linelen
   linelen = scene_size + vs.mag( cam_frame.axis.norm()*cam_dist + cam_frame.pos)
   reDrawLine( fwd_line, vs.vector(cam_dist,0,0), linelen, vs.vector(-1,0,0))
   reDrawLine( mouse_line, vs.vector(cam_dist,0,0), linelen, ray ) 
Planet = sphere(pos=initpos, radius=0.02, color=color.blue,
                make_trail=True)  #Graphic visualisation of Planet 1
Planet.trail_object.color = color.white  # make Planet 1's trail white
SecondPlanet = sphere(pos=Sinitpos,
                      radius=0.05,
                      color=color.cyan,
                      make_trail=True)  #Graphic visualisation of Planet 2
SecondPlanet.trail_object.color = color.red  # make Planet 2's trail red
Star = sphere(pos=(0, 0, 0), radius=0.08,
              color=color.yellow)  #Graphic visualisation of Star
vel = vector(-15, 0, 0)  # initial velocity of planet 1
Svel = vector(-60, 0, 0)  # initial velocity of planet 1
r = initpos  #Position vector for Planet 1
r2 = Sinitpos  #Position vector for Planet 2
while step <= maxstep:  #Run simulation in time limit defined by maximum step
    Planet.pos = r  #Set the 3D objects' location according to position vectors
    SecondPlanet.pos = r2
    vel = vel - (M * mass1 /
                 (mag(r)**3)) * r * dt + (mass1 * mass2 / (mag(r2 - r)**3)) * (
                     r2 -
                     r) * dt  #Velocity variation according to Newton's laws
    #Radially inwards interaction from star, outwards from second planet
    Svel = Svel - (M * mass2 /
                   (mag(r2)**3)) * r2 * dt + (mass1 * mass2 /
                                              (mag(r2 - r)**3)) * (r2 - r) * dt
    #Radially inwards interaction from star and first planet
    r += dt * vel  #Update position vectors
    r2 += dt * Svel
    step += 1  #Update step
    rate(75)  #Fast animation
print("end of program")
Exemplo n.º 33
0
def r3body(y, t):  # equations of motion for restricted 3body
    r, v = y[0], y[1]
    r1, r2 = r - [-a, 0], r - [b, 0]  # rel pos vectors
    acc = -GM * (b * r1 / vp.mag(r1)**3 + a * r2 / vp.mag(r2)**3)  #
    acc += omega**2 * r + 2 * omega * np.array([v[1], -v[0]])  # Coriolis term
    return np.array([v, acc])
Exemplo n.º 34
0
        k1.vel - k2.vel, wsp) * wsp
    k2.vel = k2.vel + 2.0 * k2.m / (k1.m + k2.m) * np.dot(
        k1.vel - k2.vel, wsp) * wsp
    k1.pos += k1.vel * dtp
    k2.pos += k2.vel * dtp
    print("hura")


n = 20
r = 1.
dt = 0.1
kule = []
scena = vs.display(width=550, height=550)
vs.sphere(pos=(0, 0, 0), radius=20, opacity=0.1)
for x in range(n):
    kula = vs.sphere(pos=np.random.randint(-5, 5, 3), radius=r)
    kula.m = 1.
    kula.vel = np.random.randint(-5, 5, 3)
    kule.append(kula)

while True:
    vs.rate(10)
    for k1 in kule:
        for k2 in kule:
            k1.pos += k1.vel * dt
            if np.abs(vs.mag(k1.pos - k2.pos)) <= 3.0 * r:

                calculateVelocities(k1, k2)
            if np.abs(vs.mag(k1.pos)) > 20.:
                k1.vel = -k1.vel
Exemplo n.º 35
0
 
#V is the potential.  This next line puts in zero for every value.
V=X*0
 
#In order to have a well behaved plot, Vmax sets the upper and lower limit
Vmax=4e6
 
#This double loop goes through all the values in the mesh
for i in range(len(X[:,0])):
    for j in range(len(Y[0,:])):
        #r_loc is the vector observation location based on x,y
        r_loc=vector(X[i,j],Y[i,j],0)
 
        #r1 is the vector from charge 1 to observation location
        r1=r_loc-q1
        #r2 is the vector from charge 2 to observation location
        r2=r_loc-q2
 
        #if the observation location is on either of the charge charges
        #do not computer V (it would be a division by zero)
        if mag(r1) !=0 and mag(r2)!=0:
            #calculate V
            V[i,j]=k*q1q/mag(r1) + k*q2q/mag(r2)
            #if V is too high, limit it
            if V[i,j]>=Vmax: V[i,j]=Vmax
            if V[i,j]<=-Vmax: V[i,j]=-Vmax
 
 
#the plotting part
data=[{'x':x, 'y':y, 'z':V, 'type':'contour'}]
plot_url = py.plot(data, filename='electric potential_v2')
Exemplo n.º 36
0
def dist(a,b):
    '''Returns the linear distance between a and b, i.e. the magnitude
       of the vector a - b.'''
       
    return( mag(a.pos - b.pos) )
Exemplo n.º 37
0
def get_e_field2(pos, *pos_charge_tuples):
    f = vector(0, 0, 0)
    kel = 9e9  # Coulomb constant
    for c in pos_charge_tuples:
        f = f + (pos - c[0]) * kel * c[1] / mag(pos - c[0])**3
    return f
Exemplo n.º 38
0
def get_e_field(p, *charges):
    f = vector(0, 0, 0)
    kel = 9e9  # Coulomb constant
    for c in charges:
        f = f + (p.pos - c.pos) * kel * c.q / mag(p.pos - c.pos)**3
    return f
Exemplo n.º 39
0
q2q = -1e-6

#V is the potential.  This next line puts in zero for every value.
V = X * 0

#In order to have a well behaved plot, Vmax sets the upper and lower limit
Vmax = 4e6

#This double loop goes through all the values in the mesh
for i in range(len(X[:, 0])):
    for j in range(len(Y[0, :])):
        #r_loc is the vector observation location based on x,y
        r_loc = vector(X[i, j], Y[i, j], 0)

        #r1 is the vector from charge 1 to observation location
        r1 = r_loc - q1
        #r2 is the vector from charge 2 to observation location
        r2 = r_loc - q2

        #if the observation location is on either of the charge charges
        #do not computer V (it would be a division by zero)
        if mag(r1) != 0 and mag(r2) != 0:
            #calculate V
            V[i, j] = k * q1q / mag(r1) + k * q2q / mag(r2)
            #if V is too high, limit it
            if V[i, j] >= Vmax: V[i, j] = Vmax
            if V[i, j] <= -Vmax: V[i, j] = -Vmax

#the plotting part
data = [{'x': x, 'y': y, 'z': V, 'type': 'contour'}]
plot_url = py.plot(data, filename='electric potential_v2')
Exemplo n.º 40
0
# The target is a sphere
target = V.sphere(pos=(D,H,0), radius=1, color=V.color.yellow)
target.velocity = V.vector(0,0,0)

# The 'dart gun' is just a cylinder.
gun = V.cylinder(pos=(0,0,0), axis=gun_len*sight, radius=1,
                 color = V.color.green)

# Run simulation

print 'Starting simulation...'

# Put a little delay to give all the OpenGL stuff time to initialize nicely.
time.sleep(1)

while (arrow.y >= 0 and target.y >=0) and \
          V.mag(arrow.pos-target.pos) > impact_distance:

    V.rate(75)

    for obj in (arrow,target):
        obj.pos += obj.velocity*dt
        obj.velocity += dv

# Report to user.
if V.mag(arrow.pos-target.pos) <= impact_distance:
    print 'Hit!'
else:
    print 'Miss...'
Exemplo n.º 41
0
def getfield(posn):
    """ Get the field at a given point."""
    fld = vp.vector(0, 0, 0)
    for chrg in CHARGES:
        fld = fld + (posn-chrg.pos) * 8.988e9 * chrg.Q / vp.mag(posn-chrg.pos)**3
    return fld
Exemplo n.º 42
0
def r3body(y, t):   # equations of motion for restricted 3body
    r, v = y[0], y[1]
    r1, r2 = r - [-a,0], r - [b,0]  # rel pos vectors 
    acc = -GM*(b*r1/vp.mag(r1)**3 + a*r2/vp.mag(r2)**3) # 
    acc += omega**2*r + 2*omega*np.array([v[1], -v[0]]) # Coriolis term 
    return np.array([v, acc])
Exemplo n.º 43
0
def redraw_lines():
    """ Re-Draw the lines."""
    global LINELEN
    LINELEN = SCENE_SIZE + vs.mag(CAM_FRAME.axis.norm()*CAM_DIST + CAM_FRAME.pos)
    redraw_line(FWD_LINE, vs.vector(CAM_DIST, 0, 0), LINELEN, vs.vector(-1, 0, 0))
    redraw_line(MOUSE_LINE, vs.vector(CAM_DIST, 0, 0), LINELEN, RAY)
Exemplo n.º 44
0
T_step = step_interval
s = sphere(make_trail=True, pos=[ride_radius + ride_radius2, 0, 0], radius=0.1)
s.trail_object.color = color.yellow
a_tangential = arrow(pos=[1, 0, 0], axis=[0, 1, 0], color=color.red)
a_inward = arrow(pos=[1, 0, 0], axis=[-1, 0, 0], color=color.blue)
for theta in arange(0, 100 * pi, T_step):
    rate(60)
    r = vector(ride_radius*cos(theta) + ride_radius2*cos(p*theta), \
         ride_radius*sin(theta) + ride_radius2*sin(p*theta), 0)
    velocity = vector(-ride_radius*sin(theta)-ride_radius2*p*sin(p*theta), \
         ride_radius*cos(theta)+ride_radius2*p*cos(p*theta),0)
    vel = str(velocity).strip('[]')
    acceleration = vector(-ride_radius*cos(theta) - ride_radius2*p**2*cos(p*theta), \
         -ride_radius*sin(theta) - ride_radius2*p**2*sin(p*theta), 0)
    tangential_acceleration = (dot(velocity, acceleration) /
                               mag(velocity)) * norm(velocity)
    tang_accel = str(tangential_acceleration).strip('[]')
    inward_acceleration = acceleration - tangential_acceleration
    in_accel = str(inward_acceleration).strip('[]')
    s.pos = r
    a_tangential.pos = r
    a_inward.pos = r
    a_tangential.axis = tangential_acceleration
    a_inward.axis = inward_acceleration
    data.append([theta, vel, tang_accel, in_accel])

for row in data:
    ws.append(row)

ws.append(["Major Radius: ", r1])
ws.append(["Minor Radius: ", r2])
Exemplo n.º 45
0
vel_bird = vector(v0 * np.cos(theta), v0 * np.sin(theta),
                  0)  # initial velocity of Bird
criticalspeed = 10  # Minimum speed of impact between Olaf and Bird for Olaf to be destroyed
dt = 0.001  # timestep in seconds
step = 1  # loop counter
maxstep = 500  # maximum number of calculation steps to include

#!@!@### TEMPLATE HEADER ENDS ###@!@!#

while step <= maxstep:  # While loop
    rate(80)  #Setting rate of animation to a suitable level

    #Calculating position and velocity of bird due to gravitational forces from Death Star and Death Snowball
    vel_bird = vel_bird - G * M * (
        (Bird.pos - DeathSnowball.pos) /
        (mag(Bird.pos - DeathSnowball.pos)**3)) * dt - G * M2 * (
            (Bird.pos - DeathStar.pos) /
            (mag(Bird.pos - DeathStar.pos)**3)) * dt
    Bird.pos = Bird.pos + vel_bird * dt

    #Calculating position and velocity of Death Snowball due to gravitational forces bird
    vel_DS = vel_DS - G * mbird * ((DeathSnowball.pos - Bird.pos) /
                                   (mag(DeathSnowball.pos - Bird.pos)**3)) * dt
    DeathSnowball.pos = DeathSnowball.pos + vel_DS * dt

    #Calculating position and velocity of Death Star due to gravitational forces bird
    vel_DS2 = vel_DS2 - G * mbird * ((DeathStar.pos - Bird.pos) /
                                     (mag(DeathStar.pos - Bird.pos)**3)) * dt
    DeathStar.pos = DeathStar.pos + vel_DS2 * dt

    #Keeping Olaf in position on Death Snowball
def ug_energy(self, objects):
	ug = 0
	for o in objects:
		if self.pos != o.pos:
			ug += -g * self.mass * o.mass / mag(self.pos - o.pos)
	return ug
Exemplo n.º 47
0
    spin = vp.arrow(axis=omega, pos=(0, 0, 0), length=1)  # omega dir
    info = vp.label(pos=(1.1 * R, 2, -2), text='Any key=repeat')
    return scene, ball, trail, ideal, spin


def go(x, y, vx, vy):  # motion with full drag and spin effects
    h, t, Y = 0.01, 0., np.array([[x, y, 0.], [vx, vy, 0.]])  # initialize
    while (Y[0, 0] < R and Y[0, 1] > 0.2):  # before homeplate&above ground
        vp.rate(40)
        t, Y = t + h, ode.RK4(baseball, Y, t, h)  # integrate
        ball.pos, spin.pos = Y[0], Y[0] - offset  # move ball, arrow
        spin.rotate(angle=phi), ball.rotate(angle=phi, axis=omega)  #spin
        trail.append(pos=ball.pos)
        ideal.append(pos=(x + vx * t, y + vy * t - 0.5 * g * t * t,
                          0.))  # ideal case
    while (not scene.kb.keys):  # check for key press
        vp.rate(40)
        spin.rotate(angle=phi), ball.rotate(angle=phi, axis=omega)
    scene.kb.getkey()  # clear key
    trail.append(pos=(0, 0, 0), retain=0)  # reset trails
    ideal.append(pos=(0, 0, 0), retain=0)


g, b2, alpha, mass = 9.8, .0013, 5e-5, .15  # parameters
R, omega = 18.4, 200. * np.array([0, 1, 1])  # range, angular velocity
phi, offset = np.pi / 16., 0.4 * omega / vp.mag(omega)

scene, ball, trail, ideal, spin = set_scene(R)
while (1):
    go(x=0., y=2., vx=30., vy=0.)  # initially z=0, vz=0
Exemplo n.º 48
0
def hockey(Y, t):  # return eqn of motion
    accel = 0.
    for i in range(len(loc)):
        accel += Q[i] * (Y[0] - loc[i]) / (vp.mag(Y[0] - loc[i]))**3
    return [Y[1], q * accel]  # list for non-vectorized solver
Exemplo n.º 49
0
def baseball(Y, t):  # Y = [r, v] assumed
    v = Y[1]
    fm = alpha * vp.cross(omega, v)  # Magnus force
    a = (fm - b2 * vp.mag(v) * v) / mass - [0, g, 0]  # minus g-vec
    return np.array([v, a])  # np array
Exemplo n.º 50
0
mass2 = 0.1  # mass of planet 2
pos2 = vector(0, 5.1, 0.1)  # initial position vector of planet 2
Planet2 = sphere(pos=pos2,
                 radius=1 * mass2,
                 color=color.white,
                 make_trail=True)
Planet2.trail_object.color = color.white  # make the trail white
vel2 = vector(35, 0, 0)  # initial velocity of planet 2

#Making a loop
while step <= maxstep:

    #I have added another term to the velocity equation so that the velocity of the body is affected by BOTH other bodies

    #Velocity and position calculations of planet 1 based on force from other two bodies
    vel1 = vel1 - dt * (G * M * pos1) / (mag(pos1)**3) - dt * (
        G * mass2 * pos1) / (mag(pos1)**3)
    pos1 = pos1 + vel1 * dt

    #Velocity and position calculations of planet 2 based on force from other two bodies
    vel2 = vel2 - dt * (G * M * pos2) / (mag(pos2)**3) - dt * (
        G * mass1 * (pos2 - pos1)) / (mag(pos2 - pos1)**3)
    pos2 = pos2 + vel2 * dt

    #time step
    t = t + dt

    #displayin planet and moon
    Planet1.pos = pos1
    Planet2.pos = pos2
Exemplo n.º 51
0
    vp.sphere(pos=(-1e-13, 0, 0), Q=EC, color=vp.color.red, radius=6e-15),
    vp.sphere(pos=(1e-13, 0, 0), Q=-EC, color=vp.color.blue, radius=6e-15),
]


def getfield(posn):
    """ Get the field at a given point."""
    fld = vp.vector(0, 0, 0)
    for chrg in CHARGES:
        fld = fld + (posn - chrg.pos) * 8.988e9 * chrg.Q / vp.mag(posn -
                                                                  chrg.pos)**3
    return fld


while True:
    POSN = vp.scene.mouse.getclick().pos
    FLD = getfield(POSN)
    MAG = vp.mag(FLD)
    RED = vp.maximum(1 - 1e17 / MAG, 0)
    BLUE = vp.minimum(1e17 / MAG, 1)
    if RED >= BLUE:
        BLUE = BLUE / RED
        RED = 1.0
    else:
        RED = RED / BLUE
        BLUE = 1.0
    vp.arrow(pos=POSN,
             axis=FLD * (4e-14 / 1e17),
             shaftwidth=6e-15,
             color=(RED, 0, BLUE))
Exemplo n.º 52
0
def baseball(Y, t):                 # Y = [r, v] assumed
    v = Y[1]
    fm = alpha*vp.cross(omega, v)               # Magnus force
    a = (fm - b2*vp.mag(v)*v)/mass - [0,g,0]    # minus g-vec
    return np.array([v, a])                     # np array
Exemplo n.º 53
0
vp.scene.title = "Electric Field Vectors"
vp.scene.range = 2e-13

CHARGES = [
    vp.sphere(pos=(-1e-13, 0, 0), Q=EC, color=vp.color.red, radius=6e-15),
    vp.sphere(pos=(1e-13, 0, 0), Q=-EC, color=vp.color.blue, radius=6e-15),
]

def getfield(posn):
    """ Get the field at a given point."""
    fld = vp.vector(0, 0, 0)
    for chrg in CHARGES:
        fld = fld + (posn-chrg.pos) * 8.988e9 * chrg.Q / vp.mag(posn-chrg.pos)**3
    return fld

while True:
    POSN = vp.scene.mouse.getclick().pos
    FLD = getfield(POSN)
    MAG = vp.mag(FLD)
    RED = vp.maximum(1-1e17/MAG, 0)
    BLUE = vp.minimum(1e17/MAG, 1)
    if RED >= BLUE:
        BLUE = BLUE/RED
        RED = 1.0
    else:
        RED = RED/BLUE
        BLUE = 1.0
    vp.arrow(pos=POSN, axis=FLD * (4e-14/1e17),
             shaftwidth=6e-15,
             color=(RED, 0, BLUE))
Exemplo n.º 54
0
def get_g_field(p, *sources):
    f = vector(0, 0, 0)
    G = 6.674e-11
    for s in sources:
        f = f + (p.pos - s.pos) * G * s.m / mag(p.pos - s.pos)**3
    return f
Exemplo n.º 55
0
scene = vp.display(title='Electric dipole', background=(.2,.5,1), 
                   forward=(0,-1,-.5), up=(0,0,1))
zaxis = vp.curve(pos=[(0,0,-r),(0,0,r)])                    
qpos = vp.sphere(pos=(0,0,.02), radius=0.01, color=(1,0,0))
qneg = vp.sphere(pos=(0,0,-.02), radius=0.01, color=(0,0,1))
c1 = vp.ring(pos=(0,0,0), radius=r, axis=(0,0,1), thickness=0.002)
c2 = vp.ring(pos=(0,0,0), radius=r, axis=(0,1,0), thickness=0.002)

theta, phi = np.linspace(0, np.pi, m), np.linspace(0, 2*np.pi, n) # grid 
phi, theta = vp.meshgrid(phi, theta)
rs = r*np.sin(theta)
x, y, z = rs*np.cos(phi), rs*np.sin(phi), r*np.cos(theta)   # coord. 
for i in range(m):
    for j in range(n):
        rvec = vp.vector(x[i,j], y[i,j], z[i,j])
        B = scale*vp.cross(rvec, vp.vector(0,0,1))/(r*r)    # $\vec{r}\times \hat z/r^2$
        E = vp.cross(B, rvec)/r                             # $\vec{B}\times \vec{r}/r$
        vp.arrow(pos=rvec, axis=E, length=vp.mag(E), color=(1,1,0))
        vp.arrow(pos=rvec, axis=B, length=vp.mag(B), color=(0,1,1))
    
    
    
    
    
    
    
    
    
    
   
Exemplo n.º 56
0
def drawCameraFrame():  # create frame and draw its contents
    global cam_box, cent_plane, cam_lab, cam_tri, range_lab, linelen, fwd_line
    global fwd_arrow, mouse_line, mouse_arrow, mouse_lab, fov, range_x, cam_dist, cam_frame
    global ray
    cam_frame = vs.frame(pos=vs.vector(
        0,
        2,
        2,
    ), axis=(0, 0, 1))
    # NB: contents are rel to this frame.  start with camera looking "forward"
    # origin is at simulated scene.center
    fov = vs.pi / 3.0  # 60 deg
    range_x = 6  # simulates scene.range.x
    cam_dist = range_x / vs.tan(
        fov / 2.0)  # distance between camera and center.
    ray = vs.vector(-20.0, 2.5,
                    3.0).norm()  # (unit) direction of ray vector (arbitrary)
    #  REL TO CAMERA FRAME
    cam_box = vs.box(frame=cam_frame,
                     length=1.5,
                     height=1,
                     width=1.0,
                     color=clr.blue,
                     pos=(cam_dist, 0, 0))  # camera-box
    cent_plane = vs.box(frame=cam_frame,
                        length=0.01,
                        height=range_x * 1.3,
                        width=range_x * 2,
                        pos=(0, 0, 0),
                        opacity=0.5)  # central plane
    cam_lab = vs.label(frame=cam_frame,
                       text='U',
                       pos=(cam_dist, 0, 0),
                       height=9,
                       xoffset=6)
    cam_tri = vs.faces(frame=cam_frame,
                       pos=[(0, 0, 0), (0, 0, -range_x), (cam_dist, 0, 0)])
    cam_tri.make_normals()
    cam_tri.make_twosided()
    range_lab = vs.label(frame=cam_frame,
                         text='R',
                         pos=(0, 0, -range_x),
                         height=9,
                         xoffset=6)
    linelen = scene_size + vs.mag(cam_frame.axis.norm() * cam_dist +
                                  cam_frame.pos)
    # len of lines from camera
    fwd_line = drawLine(vs.vector(cam_dist, 0, 0), linelen,
                        vs.vector(-1, 0, 0))
    fwd_arrow = vs.arrow(frame=cam_frame,
                         axis=(-2, 0, 0),
                         pos=(cam_dist, 0, 0),
                         shaftwidth=0.08,
                         color=clr.yellow)
    vs.label(frame=cam_frame,
             text='C',
             pos=(0, 0, 0),
             height=9,
             xoffset=6,
             color=clr.yellow)
    mouse_line = drawLine(vs.vector(cam_dist, 0, 0), linelen, ray)
    mouse_arrow = vs.arrow(frame=cam_frame,
                           axis=ray * 2,
                           pos=(cam_dist, 0, 0),
                           shaftwidth=0.08,
                           color=clr.red)
    mouse_lab = vs.label(frame=cam_frame,
                         text='M',
                         height=9,
                         xoffset=10,
                         color=clr.red,
                         pos=-ray * (cam_dist / vs.dot(ray, (1, 0, 0))) +
                         (cam_dist, 0, 0))
Exemplo n.º 57
0
def mercury(id, r, v, t):  # eqns of motion for mercury
    if (id == 0): return v  # velocity, dr/dt
    s = vp.mag(r)
    return -GM * r * (1.0 + lamb /
                      (s * s)) / (s * s * s)  # acceleration, dv/dt