def run(gravity, pendulumLength, initialTheta, initialOmega, initialTime, timeStep, maxTime, dragCoefficient, drivingForce, drivingFrequency): import vpython import numpy as np scene.title = "Complex Pendulum" barLength = 0.5 sphereRadius = 0.05 pendulum = makePendulum(barLength, sphereRadius) currentTime = initialTime currentTheta = initialTheta currentOmega = initialOmega naturalFrequency = np.sqrt(gravity / pendulumLength) pendulum.rotate(origin=vector(0, 0, 0), angle=currentTheta, axis=vector(0, 0, 1)) vpython.sleep(1) while currentTime <= maxTime: currentOmega = currentOmega + ( -naturalFrequency**2 * np.sin(currentTheta) - dragCoefficient * currentOmega + drivingForce * np.sin(drivingFrequency * currentTime)) * timeStep lastTheta = currentTheta currentTheta = currentTheta + currentOmega * timeStep currentTime = currentTime + timeStep rate(60) pendulum.rotate(origin=vector(0, 0, 0), angle=currentTheta - lastTheta, axis=vector(0, 0, 1))
def main(): global Key_Event player = Player('s', 'w', 'a', 'd', color.red, player_number='first') # blue_player = Player('k', 'i', 'j', 'l', color.blue, player_number='second') # players = [red_player, blue_player] scene.bind('keydown', capture_key) columns, rows = 8, 24 board = draw_board(columns, rows) scene.center = vector(int(columns / 2), int(rows / 2) - 3, 0) scene.range = columns + 2 scene.autoscale = False while True: for _ in range(5): sleep(( 0.16 - int(board['level']) * 0.01) if board['level'] <= 15 else 0.01) received_inputs = Key_Event player.receive_input(board, received_inputs) player.update_shadow(board) Key_Event = [] loss_check = player.nat_drop(board) if loss_check == 'FAILURE': return player.update_shadow(board)
def apply_rotation(cycle_points, rot_info_list, anim_steps=45): """ animate the rotation of all points in 'cycle_points' as specified in 'rot_info_list'. the animation contains 'anim_steps' frames inputs: ------- cycle_points - (list) - list of vpython objects that shall be rotated rot_info_list - (list) - list with rotation information triples: ('angle', 'axis', 'origin') of rotation for each object anim_steps - (int) - number of frames for the animation returns: -------- None outputs: -------- changes the position of every object in cycle_points by rotation as specified in 'rot_info_list' """ for _ in range(anim_steps): for obj, rot_info in zip(cycle_points, rot_info_list): angle, axis, com = rot_info obj.rotate(angle=angle / anim_steps, axis=axis, origin=com) obj.rotate(angle=angle / anim_steps, axis=-axis) vpy.sleep(0.01)
def replayLoop(): if len(MooView.viewList) == 0: return numFrames = MooView.viewList[0].numFrames() while MooView.viewList[0].replayButton.text == "Stop Replay": for idx in range(numFrames): for view in MooView.viewList: view.replaySnapshot(idx) vp.sleep(MooView.viewList[0].sleep) vp.sleep(0.5) # Pause 0.5 sec between replays
def updateValues(self): simTime = moose.element('/clock').currentTime #self.timeStr.set_text( "Time= {:.3f}".format( time ) ) for i in self.drawables_: i.updateValues(simTime) if self.doRotation and abs(self.rotation) < 2.0 * 3.14 / 3.0: self.scene.forward = vp.rotate(self.scene.forward, angle=self.rotation, axis=self.scene.up) self.updateAxis() if self.viewIdx == 0: self.timeLabel.text = "Time = {:7.3f} sec".format(simTime) vp.sleep(self.sleep)
def main(): global Key_Event scene.bind('keydown', capture_key) end_of_game = False columns, rows = 10, 24 scene.height = 550 board = draw_board(columns, rows) scene.center = vector(int(columns / 2), int(rows / 2) - 3, 0) scene.range = columns + 2 scene.autoscale = False red_player = Player('q', 'e', 's', 'w', 'a', 'd', color.red, player_number='first') blue_player = Player('u', 'o', 'k', 'i', 'j', 'l', color.blue, player_number='second') players = [red_player, blue_player] while not end_of_game: for _ in range(5): sleep(( 0.16 - int(board['level']) * 0.01) if board['level'] <= 15 else 0.01) received_inputs = Key_Event for player in players: player.receive_input(board, received_inputs) for player in players: player.update_shadow(board) Key_Event = [] for player in players: loss_check = player.nat_drop(board) if loss_check == 'FAILURE': end_of_game = game_over(board, players) player.update_shadow(board)
func, initcond, t, args=(g, ), full_output=True ) #solucion de la ecuacion diferencial (parametros acordes a los definidos en la funcion) theta, omega, ll, rr = solu.T # solucion para cada paso de theta y omega # ===================== scene.range = 0.2 # tamaño de la ventana de fondo xp = l * sin(thes) #pasa de coordenadas polares a cartesinas yp = -l * cos(thes) zp = 0. sleeptime = 0.0001 # tiempon con el que se utiliza la posicion de la particula prtcl = sphere(pos=vector(xp, yp, zp), radius=R, color=color.cyan) #define objeto con que se va a trabajar time_i = 0 #es un contador que se mueve ene el espacio temporal en donde se resolvio la ecuacion deferencial t_run = 0 #tiempo en el q se ejecuta la animacion #for i in omega: # print(i) while t_run < t_final: #animacion sleep(sleeptime) prtcl.pos = vector(l * sin(theta[time_i]), -l * cos(theta[time_i]), zp) t_run += t_delta time_i += 1
condINI=array([thetaI,thetaIp,phiI,phiIp]) sol=odeint(solucion,condINI,t,args=(g,l,k,m)) xp=l*thetaI yp=-l zp=0 r=1 pendulo1=sphere(pos=vector(xp,yp,zp),radius=r,color=color.green) pendulo2=sphere(pos=vector(xp+l,yp,zp),radius=r,color=color.green) #cuerda1=curve(vector(0,0,0),pendulo1.pos) #cuerda2=curve(vector(l,0,0),pendulo2.pos) cuerdas1=cylinder(pos=pendulo2.pos,axis=vector(0,0,0),radius=0.1,color=color.white) cuerdas2=cylinder(pos=pendulo2.pos,axis=vector(l,0,0),radius=0.1,color=color.white) base=box(pos=vector(l/2,0,0),size=vector(l+2,0.1,0.1),color=color.orange) spring=helix(pos=pendulo2.pos,axis=vector(0,0,0),radius=0.3,constant=k,thickness=0.1,coils=10,color=color.white) ti=0 while ti<tf: sleep(0.01) pendulo1.pos=vector(l*sol[ti,0],yp,zp) pendulo2.pos=vector(l*sol[ti,2]+l,yp,zp) cuerdas2.pos=pendulo2.pos cuerdas2.axis=vector(l,0,0)-cuerdas2.pos cuerdas1.pos=pendulo1.pos cuerdas1.axis=vector(0,0,0)-cuerdas1.pos spring.pos=pendulo1.pos spring.axis=pendulo2.pos-spring.pos ti = ti + 1
tin = 0. #tiempo inicial tfin = 15. #tiempo final tdif = (tfin - tin) / pasos #diferencial de tiempo t = linspace(tin, tfin, pasos) #arreglo de diferencial de tiempo soluc, outodeint = odeint( funcion, initcond, t, args=(g, ), full_output=True ) #solucion de la ecuacion diferencial (parametros acordes a los definidos en la funcion) theta, omega, ll, rr = soluc.T # solucion para cada paso de theta y omega scene.range = 0.2 # tamaño de la ventana de fondo xp = l * sin(thes) #pasa de coordenadas polares a cartesinas yp = -l * cos(thes) zp = 0. actime = 0.0001 # tiempon con el que se utiliza la posicion de la particula prtcl = sphere(pos=vector(xp, yp, zp), radius=R, color=color.red) #define objeto con que se va a trabajar contime = 0 #es un contador que se mueve ene el espacio temporal en donde se resolvio la ecuacion deferencial runtime = 0 #tiempo en el q se ejecuta la animacion while runtime < tfin: #animacion sleep(actime) prtcl.pos = vector(l * sin(theta[contime]), -l * cos(theta[contime]), zp) runtime += tdif contime += 1
def choose_branch(nb_branches, Q, state, e): if (np.count_nonzero(Q[state]) == 0 or np.random.rand(1) < e): chosen_branch = np.random.choice(nb_branches) else: chosen_branch = Q[state].argmax() return chosen_branch tree_actions_index = np.load("tree_actions_index.npy") env = Carom(render=False) actions = env.get_actions() env.reset() sleep(2) nb_branches = len(tree_actions_index[0, 0]) # action_index = int(tree_actions_index[0,0][2]) # env.step(actions[action_index][0],actions[action_index][1],actions[action_index][2],actions[action_index][3],actions[action_index][4]) # action_index = int(tree_actions_index[1,2][2]) # env.step(actions[action_index][0],actions[action_index][1],actions[action_index][2],actions[action_index][3],actions[action_index][4]) # action_index = int(tree_actions_index[2,8][1]) # env.step(actions[action_index][0],actions[action_index][1],actions[action_index][2],actions[action_index][3],actions[action_index][4]) nb_states = 0 num_episodes = 700 lr = .8 y = .95 e = 0.2 episodes = [] episode_rewards = [] for i in range(tree_actions_index.shape[0]):
theta, omega = solu.T #matriz de 2*2 ( columnas para los pasos) solucion para cada paso de theta y omega , se definen las variables y solu.t devuelve la matriz transpuesta en los valores de theta y omega # ===================== scene.range = 0.2 # tamaño de la pantalla a visualizar xp = l * sin(thes) #coordenadas cartesianas de la esfera con el angulo inicial yp = -l * cos(thes) #igual zp = 0. #igual sleeptime = 0.0001 #tiempo con que la maquina actualiza la posicion de la particula prtcl = sphere(pos=vector(xp, yp, zp), radius=R, color=color.cyan ) #Define la particula con coordenadas iniciales dadas xp,yp,zp time_i = 0 #defino contador que se mueve en el espacio que se soluciona la Ecuf difencial t_run = 0 #con el que se corre la animacion #for i in omega: # print(i) while t_run < t_final: #condicion para la animacion sleep(sleeptime) #duerme prtcl.pos = vector( l * sin(theta[time_i]), -l * cos(theta[time_i]), zp) #actualiza posicion de la particula aumenta el contador t_run += t_delta #contadores y acumuladores time_i += 1 #igual
def new_thread(): _thread.start_new_thread(Path_Calc) vp.button(bind=new_thread, text='Path Calc') start = False def Go(): global start start = True vp.button(bind=Go, text='go') time = 0 while time < total_steps: if start == False: vp.sleep(1) continue vp.rate(500) for j in range(len(Electrons)): Electrons[j].pos = paths[j][time] time += 1 #print('step')
thickness=.1) angle = 0 da = .01 trail = vp.curve(color=vp.color.magenta, radius=.02) trail.append(vp.vector(1, 0, 0)) trail.append(vp.vector(1, 0, 2)) trail.append(vp.vector(2, 0, 2)) while angle < 3 * vp.pi / 4: vp.rate(100) ptr.rotate(angle=da, axis=vp.vector(0, 0, 1), origin=ptr.pos) trail.append(ptr.pos + ptr.axis) angle += da vp.sleep(1) # sleep for 1 second vp.scene.autoscale = False vp.scene.append_to_caption("""Drag the mouse and you'll drag a sphere. On a touch screen, press and hold, then drag.""") t = 0 dt = .01 y0 = gslabel.pos.y ball_yo = ball.pos.y while t < 10: vp.rate(1 / dt) ball.pos.y = ball_yo + 0.5 * vp.sin(-4 * t) spring.length = ball.pos.y - spring.pos.y - ball.radius + 0.15 gslabel.yoffset = 28 * vp.sin(-4 * t) t += dt
def show( sec=10 ): # Animate scene for N seconds - use when importing library manually vpython.sleep(sec)
def launch(sample_rate, position, orientation, COM, COP, thrust, gravity, lift, drag): for step in range(len(position)): position[step][2] = -position[step][2] force_scale = 0.01 l = 2 rad = 0.09 steps = len(position) # Initialization of enviorment render = vp.canvas(height=600, width=1200, background=vp.vector(0.8, 0.8, 0.8), forward=vp.vector(1, 0, 0), up=vp.vector(0, 0, 1)) render.select() render.caption = "Loading..." render.visible = False # Initialization of body and cone body = vp.cylinder(pos=vp.vector(-l, 0, 0), axis=vp.vector(l*0.8, 0, 0), radius=rad) cone = vp.cone(pos=vp.vector(-l*0.2, 0, 0), axis=vp.vector(l*0.2, 0, 0), radius=rad) # Initialization of fins a_fins = vp.box(pos=vp.vector(-l + (l*0.05), 0, 0), size=vp.vector(l*0.1, rad*4, rad*0.25)) b_fins = vp.box(pos=vp.vector(-l + (l*0.05), 0, 0), size=vp.vector(l*0.1, rad*0.25, rad*4)) inv_box = vp.box(pos=vp.vector(l/2, 0, 0), size=vp.vector(l, 10e-10, 10e-10), visible=False) # Initialization of rocket rocket = vp.compound([body, cone, a_fins, b_fins, inv_box], pos=vp.vector(0, 0, 1), axis=vp.vector(1, 0, 0), up=vp.vector(0, 0, 1), color=vp.vector(1,1,1), opacity=0.5) COM_sphere = vp.sphere(radius = 0.04, color=vp.vector(0, 0, 0)) COP_sphere = vp.sphere(radius = 0.04, color=vp.vector(0, 0, 0)) thrust_pointer = vp.arrow(shaftwidth = 0.1, color=vp.vector(1, 1, 0)) gravity_pointer = vp.arrow(shaftwidth = 0.1, color=vp.vector(0, 1, 1)) lift_pointer = vp.arrow(shaftwidth = 0.1, color=vp.vector(1, 0, 1)) drag_pointer = vp.arrow(shaftwidth = 0.1, color=vp.vector(0, 0, 1)) a = 4 c = 0.3 b = a - c sqr_out = [[-a, a],[a, a],[a, -a],[-a, -a], [-a, a]] sqr_in1 = [[-b, b - 3*c],[b, b - 3*c],[b, -b],[-b, -b], [-b, b - 3*c]] sqr_in2 = [[-b, b],[b, b], [b, b - 2*c],[-b, b - 2*c], [-b, b]] ref_box = vp.extrusion(path=[vp.vector(-c/2, 0, 0), vp.vector(c/2, 0, 0)], shape=[sqr_out, sqr_in1, sqr_in2], color=vp.vector(0.5, 0.5, 0.5)) render.camera.follow(rocket) render.autoscale = False launch_pad = vp.box(pos=vp.vector(position[0][0], position[0][1], -1), size=vp.vector(16, 16, 2), color=vp.vector(0.2, 0.2, 0.2)) launch_pad = vp.box(pos=vp.vector(position[-1][0], position[-1][1], -1), size=vp.vector(16, 16, 2), color=vp.vector(0.2, 0.2, 0.2)) rocket.normal = vp.cross(rocket.up, rocket.axis) #vp.attach_arrow(rocket, 'up', color=vp.color.green) #vp.attach_arrow(rocket, 'axis', color=vp.color.blue) #vp.attach_arrow(rocket, 'normal', color=vp.color.red) roll = 0 vp.attach_trail(rocket, radius=rad/3, color=vp.color.red) sqr_out = [[-a, a],[a, a],[a, -a],[-a, -a], [-a, a]] sqr_in1 = [[-b, b - 3*c],[b, b - 3*c],[b, -b],[-b, -b], [-b, b - 3*c]] sqr_in2 = [[-b, b],[b, b], [b, b - 2*c],[-b, b - 2*c], [-b, b]] for step in range(2, steps): if not step % 5: a = 4 c = 0.3 b = a - c ref = vp.extrusion(path=[vp.vector(0, 0, 0), vp.vector(c, 0, 0)], shape=[sqr_out, sqr_in1, sqr_in2], axis=vp.vector(1, 0, 0), up=vp.vector(0, 1, 0), pos=vp.vector(position[step][0], position[step][1], position[step][2])) ref.up = vp.vector(0, 0, 1) ref.rotate(angle=orientation[step][0], axis=vp.cross(ref.axis, ref.up)) ref.rotate(angle=orientation[step][1], axis=ref.up) ref.rotate(angle=orientation[step][2], axis=ref.axis) render.caption = "Running" render.visible = True for step in range(steps): x = position[step][0] y = position[step][1] z = position[step][2] rocket.normal = vp.cross(rocket.axis, rocket.up) pitch, yaw, roll = orientation[step][0], orientation[step][1], orientation[step][2] COM_x = x + COM[step] * np.cos(yaw) * np.cos(pitch) COM_y = y + COM[step] * np.sin(yaw) * np.cos(pitch) COM_z = z + COM[step] * np.sin(pitch) COP_x = x + COP[step] * np.cos(yaw) * np.cos(pitch) COP_y = y + COP[step] * np.sin(yaw) * np.cos(pitch) COP_z = z + COP[step] * np.sin(pitch) thrust_x = x + (-l) * np.cos(yaw) * np.cos(pitch) thrust_y = y + (-l) * np.sin(yaw) * np.cos(pitch) thrust_z = z + (-l) * np.sin(pitch) thrust_mag = np.linalg.norm(thrust[step]) * force_scale thrust_ax_x = thrust_mag * np.cos(yaw) * np.cos(pitch) thrust_ax_y = thrust_mag * np.sin(yaw) * np.cos(pitch) thrust_ax_z = thrust_mag * np.sin(pitch) lift_mag = lift[step][0] * force_scale lift_ax_x = 0 lift_ax_y = 0 lift_ax_z = lift_mag drag_mag = np.linalg.norm(drag[step]) * force_scale print(lift_mag) drag_ax_x = drag_mag drag_ax_y = 0 drag_ax_z = 0 gravity_mag = np.linalg.norm(gravity[step]) * force_scale thrust_pointer.pos = vp.vector(thrust_x, thrust_y, thrust_z) thrust_pointer.axis = vp.vector(thrust_ax_x, thrust_ax_y, thrust_ax_z) gravity_pointer.pos = vp.vector(COM_x, COM_y, COM_z) gravity_pointer.axis = vp.vector(0, 0, -gravity_mag) lift_pointer.pos = vp.vector(COP_x, COP_y, COP_z) lift_pointer.axis = vp.vector(lift_ax_x, lift_ax_y, lift_ax_z) drag_pointer.pos = vp.vector(COP_x, COP_y, COP_z) drag_pointer.axis = vp.vector(drag_ax_x,drag_ax_y, drag_ax_z) rocket.rotate(angle=pitch, axis=rocket.normal) rocket.rotate(angle=yaw, axis=rocket.up) rocket.rotate(angle=roll, axis=rocket.axis) COM_sphere.pos = vp.vector(COM_x, COM_y, COM_z) COP_sphere.pos = vp.vector(COP_x, COP_y, COP_z) rocket.pos = vp.vector(x, y, z) vp.sleep(1/sample_rate) if step + 1 != steps: rocket.rotate(angle=-roll, axis=rocket.axis) rocket.rotate(angle=-yaw, axis=rocket.up) rocket.rotate(angle=-pitch, axis=rocket.normal) render.caption = "Done"