def init_vpython(self): scene = canvas(title="Fans", width=self.win, height=self.win, x=0, y=0, center=vec(0, 0, 0), forward=vec(1,0,-1), up=self.up) scene.autoscale = False scene.range = 25 h = 0.1 mybox = box(pos=vec(0, 0, -h/2), length=self.L, height=h, width=L, up=self.up, color=color.white) # create dust particles for pos in self.positions: p = sphere(pos=vec(*pos), radius=self.radius, color=color.red) p.update = True # to determine if needs position update self.particles.append(p)
def create_vis(self, canvas=None): """ Creates a visualisation. By default, uses a vpython canvas, so imports vpython. Subclass class and change this to change the way visualisations are made. Parameters ---------- canvas: vpython canvas display into which the visualization is drawn """ import vpython #self.scene stores the display into which the system draws if not canvas: if not self.scene: self.scene = vpython.canvas() if canvas: self.scene = canvas # Draw particles if they aren't drawn yet for particle in self.particles: if not particle._visualized: self.spheres.append(vpython.sphere(pos=vector_from(particle.pos), radius=particle.radius, color=vector_from(particle.color), opacity=particle.alpha, display=self.scene)) particle._visualized = True # Draw springs if they aren't drawn yet for spring in self.springs: if not spring._visualized: self.helices.append(vpython.helix(pos=vector_from(spring.particle_1.pos), axis=vector_from(spring.axis), radius=spring.radius, opacity=spring.alpha, color=vector_from(spring.color), display=self.scene)) spring._visualized = True # Draw pointers if they aren't drawn yet for pointer in self.pointers: if not pointer._visualized: self.arrows.append(vpython.arrow(pos=vector_from(pointer.pos), axis=vector_from(pointer.axis), shaftwidth=pointer.shaftwidth, opacity=pointer.alpha, color=vector_from(pointer.color), display=self.scene)) pointer._visualized = True
h = 0.1 mybox = box(pos=vec(0, 0, -h/2), length=L, height=h, width=L, up=up, color=gray) m = 1 # kg radius = 0.5 # arbitrary for now dt = 1e-3 start = vec(0, 0, radius) v0 = vec(0, 0, 10) g = vec(0, 0, -9.81) Fg = m*g particles =[] for position, c in zip([start, start+vec(0, 3*radius, 0)], [color.red, color.blue]): p = sphere(pos=position, radius=radius, color=c) p.v = v0 p.update = True # to determine if needs position update particles.append(p) # In[ ]: k = 1 while True: rate(500) # update position first for p in particles: if p.update:
import math import time win = 700 scene = vpython.canvas(title="Moon's Orbit", width=win, height=win) scene.lights = [] scene.ambient = vpython.color.gray(0.1) sunlight = [ vpython.distant_light(direction=v(-1, 0, 0), color=v(1.0, 1.0, 1.0)), vpython.distant_light(direction=v(-1, 0, 0), color=v(1.0, 1.0, 1.0)), vpython.distant_light(direction=v(-1, 0, 0), color=v(1.0, 1.0, 1.0)) ] starteaxis = v(1, 0, 0) earth = vpython.sphere(texture=vpython.textures.earth, up=v(0, 0, 1), axis=starteaxis) earth.pos = v(0, 0, 0) earth.radius = 1.5 earth.rotperiod = 1.0 moon = vpython.sphere() moon.radius = 0.5 moon.color = vpython.color.gray(0.3) moon.a = 5 # Semi-major axis moon.e = 0.0 # eccentricity of orbit (0=circle) moon.pos = v(moon.a * (1 - moon.e), 0, 0) startpos = v(moon.a * (1 - moon.e), 0, 0) moon.sidperiod = 27.321661 # Sidereal Period (moon's 'year', in Earth days) moon.rotperiod = 27.321661 # Length of the planets sidereal day, in Earth days
def c_angles(pt): # Find theta 1 t1 = arctan2(pt[1], pt[0]) a = rpv_r / cos(pi/2-t1) b = rpv_r u = rpv_offset + rpv_r # Rotation matrix for the scan points r_z = array([[cos(-t1), -sin(-t1), 0], [sin(-t1), cos(-t1), 0], [0, 0, 1]]) new_pt = zeros(3) new_pt[0] = dot(r_z, array([[pt[0]], [pt[1]], [pt[2]]]))[0] new_pt[1] = dot(r_z, array([[pt[0]], [pt[1]], [pt[2]]]))[1] new_pt[2] = dot(r_z, array([[pt[0]], [pt[1]], [pt[2]]]))[2] try: slope = - a * (new_pt[2] - u) / (b * sqrt(-new_pt[2] ** 2 + 2 * u * new_pt[2] - u ** 2 + b ** 2)) except: print("Error with Slope") te = arctan(1 / slope) if (pi / 2 - arctan2(a5, a4)) <= te <= 0: print("Theta_extra :", round(rad2deg(te), 2)) input("ERROR: Theta_extra is outside of range. Press Enter to continue...") # Find parameters to calculate j4 location h4 = cos(pi / 2 - te) * a4 tp1 = te tp2 = pi / 2 - tp1 h5 = sin(tp2) * a5 r1 = sin(pi / 2 - te) * a4 r2 = cos(tp2) * a5 xj4 = pt[0] - cos(t1) * (r1 - r2) yj4 = pt[1] - sin(t1) * (r1 - r2) zj4 = pt[2] - (h4 + h5) j4_loc = array([xj4, yj4, zj4]) vp.sphere(pos=vp.vector(j4_loc[0], j4_loc[1], j4_loc[2]), color=vp.color.red, radius=0.1) # Find joint 2 location j2_loc = array([cos(t1) * a1, sin(t1) * a1, 0]) r = j4_loc - j2_loc # Technically j4 -j2 r_norm = linalg.norm(r) gamma_1 = arcsin(j4_loc[2] / r_norm) phi_2 = arccos((a2 ** 2 + r_norm ** 2 - a3 ** 2) / (2 * a2 * r_norm)) t2 = phi_2 - gamma_1 # Find theta 3 t3 = arccos((a3 ** 2 + a2 ** 2 - r_norm ** 2) / (2 * a3 * a2)) - pi # Find theta 4 r0_4 = array([[cos(t1), 0, -sin(t1)], [sin(t1), 0, cos(t1)], [0, -1, 0]]) r0_3 = array([[-sin(t2) * sin(t3) * cos(t1) + cos(t1) * cos(t2) * cos(t3), -sin(t2) * cos(t1) * cos(t3) - sin(t3) * cos(t1) * cos(t2), -sin(t1)], [-sin(t1) * sin(t2) * sin(t3) + sin(t1) * cos(t2) * cos(t3), -sin(t1) * sin(t2) * cos(t3) - sin(t1) * sin(t3) * cos(t2), cos(t1)], [-sin(t2) * cos(t3) - sin(t3) * cos(t2), sin(t2) * sin(t3) - cos(t2) * cos(t3), 0]]) inv_r0_3 = linalg.inv(r0_3) r3_4 = dot(inv_r0_3, r0_4) t4 = arccos(r3_4[0][0]) - te return t1, t2, t3, t4
plt.figure() for i in range(len(r[c, :]) // 2): plt.plot(time, r[:, i]) plt.xlim(0, 20) #plt.ylim(0,.4) plt.show() return r, time, oscN rs, t, Nosc = Numerical_DE(5, 0, 20, 1000) from vpython import box, sphere, cylinder, color, vector, rate radi = .105 balls = np.empty(Nosc, sphere) displ = rs[:, :Nosc] print(len(displ[0, :])) for k in range(5): balls[k] = sphere(pos=vector(.75 * k, 0, 0), radius=radi, color=color.red) while True: for x in range(len(displ[:, 0])): rate(100) for i, b in enumerate(balls): b.pos = vector(.75 * i - displ[x, i], 0, 0)
import vpython as vp initial_position = vp.vector(-1., 0., 0.) initial_velocity = vp.vector(1., 0., 0.) initial_position_2 = vp.vector(1., 0., 0) initial_velocity_2 = vp.vector(1, 0, 0) ball = vp.sphere(pos=initial_position, radius=0.1, color=vp.color.red, make_trail=True, trail_type='points') ball_2 = vp.sphere(pos=initial_position_2, radius=0.1, color=vp.color.yellow, make_trail=True, trail_type='points') animation_time_step = 0.1 # seconds rate_of_animation = 1 / animation_time_step time_step = 0.05 stop_time = 10. time = 0. while time < stop_time: vp.rate(rate_of_animation) x = initial_position.x + initial_velocity.x * time y = initial_position.y + initial_velocity.y * time z = initial_position.z + initial_velocity.z * time ball.pos = vp.vector(x, y, z) x = initial_position_2.x + initial_velocity_2.x * time y = initial_position_2.y + initial_velocity_2.y * time z = initial_position_2.z + initial_velocity_2.z * time
linkz_color = np.zeros((lattice_size,lattice_size,lattice_size), dtype=vector) # Color and size the sites and links color_sites(site_color, lattice_size) color_links(linkx_color, linky_color, linkz_color, lattice_size) size_sites(site_radii, lattice_size) size_links(link_radii_x, link_radii_y, link_radii_z, lattice_size) # Generate lattice for i in range(lattice_size+1): for j in range(lattice_size+1): for k in range(lattice_size+1): op_factor = 6/((i+1)**op + (j+1)**op + (k+1)**op) sphere(pos=vector(i,j,k), radius=site_radii[i-1,j-1,k-1], color=site_color[i-1,j-1,k-1], opacity=op_factor) for i in range(lattice_size): for j in range(lattice_size): for k in range(lattice_size): op_factor = 6/((i+1)**op + (j+1)**op + (k+1)**op) cylinder(pos=vector(i,j,k), axis=vector(1,0,0), radius=link_radii_x[i,j,k], color=linkx_color[i,j,k], opacity=op_factor) cylinder(pos=vector(i,j,k), axis=vector(0,1,0), radius=link_radii_y[i,j,k], color=linky_color[i,j,k],
theta_output.text = s.value def get_length(s): length_output.text = s.value # SET THE SCENE AND 3D OBJECTS scene = vp.canvas(width=500, height=400, userspin=False, userzoom=False, title="Ideal Pendulum Simulation by haiq70", autoscale=False, center=vp.vector(0, -3, 0)) bob = vp.sphere(pos=vp.vector(0, -length, 0), radius=0.5) string = vp.cylinder(pos=vp.vector(0, 0, 0), axis=vp.vector(0, -length, 0), radius=0.02) # BUTTONS vp.button(bind=start_button_clicked, text='Start') vp.button(bind=pause_button_clicked, text='Pause') scene.append_to_caption('\n\n') # SLIDER (SPATIAL DEVIATION) scene.append_to_caption("Spatial deviation: ") slider_sd = vp.slider(min=0.1, max=90, bind=get_theta, step=0.1, value=5) theta_output = vp.wtext(text=slider_sd.value) scene.append_to_caption(" \u00b0 \n")
from vpython import sphere, vector, color # Constants L = 2 R = 0.3 if __name__ == "__main__": for i in range(-L, L + 1): for j in range(-L, L + 1): for k in range(-L, L + 1): if ((i + j + k) % 2) == 0: sphere(pos=vector(i, j, k), radius=R, color=color.blue) else: sphere(pos=vector(i, j, k), radius=R, color=color.white)
import vpython as vp initial_position_1 = vp.vector(-10, 12, 1) initial_velocity_1 = vp.vector(10, -12, -2) ball_1 = vp.sphere(pos=initial_position_1, radius=0.5, color=vp.color.cyan, make_trail=True) initial_position_2 = vp.vector(-10, -5, -1) initial_velocity_2 = vp.vector(14, 5, 2) ball_2 = vp.sphere(pos=initial_position_2, radius=0.5, color=vp.color.yellow, make_trail=True) wall_center = vp.vector(0., 0., 0.) wall_dimensions = vp.vector(0.25, 10., 10.) wall = vp.box(pos=wall_center, size=wall_dimensions, color=vp.color.magenta) animation_time_step = 0.01 # seconds rate_of_animation = 1 / animation_time_step time_step = 0.005 stop_time = 2 time = 0. ball_velocity_1 = initial_velocity_1 ball_velocity_2 = initial_velocity_2 while time < stop_time: vp.rate(rate_of_animation) if ball_1.pos.x > wall.pos.x - 0.30:
# ===================== scene.range = 0.2 #Tamaño de la ventana de fondo xp = l * sin(phi1) #Pasa de coordenadas polares a cartesianas yp = -l * cos(phi1) zp = 0. xs = l * (sin(phi1) + sin(phi2)) ys = -l * (cos(phi1) + cos(phi2)) zs = 0. sleeptime = 0.0001 #Tiempo con que se actualiza la posición de la partícula prtcl = sphere(pos=vector(xp, yp, zp), radius=R, color=color.green) #Primera esfera prtcls = sphere(pos=vector(xs, ys, zs), radius=R, color=color.blue) #Segunda esfera time_i = 0 #Contador que se mueve en el espacio temporal en el que se resolvió la ecuación diferencial t_run = 0 #Tiempo en el que se ejecuta la animación #for i in omega: # print(i) while t_run < t_final: #ANIMACIÓN prtcl.pos = vector(l * sin(phi_1[time_i]), -l * cos(phi_1[time_i]), zp) prtcls.pos = vector(l * (sin(phi_1[time_i]) + sin(phi_2[time_i])), -l * (cos(phi_1[time_i]) + cos(phi_2[time_i])), zs) t_run += t_delta sleep(sleeptime)
def __init__(self, planetDataList, maxTrailLength, planetObjectList): name = planetDataList[0] planetOrbitRadius = planetDataList[1] planetPeriod = planetDataList[2] # eccentricity = planetDataList[3] mass = planetDataList[4] sphereRadius = planetDataList[5] self.name = name self.sphereRadius = sphereRadius self.mass = mass self.lastPeriodEndTime = 0 self.halfPeriodCounter = 1 self.timeList = [] self.positionList = [] self.velocityList = [] self.periodLengthList = [] if self.name != 'Sun': # eccentricityModifier = planetOrbitRadius - (planetOrbitRadius * eccentricity) # to include eccentricity, replace planetOrbitRadius on next line with eccentricityModifier. I do not believe this produces an accurate eccentricity, but it does make the orbit elliptical. initialVelocity = (2 * pi * planetOrbitRadius) / planetPeriod self.velocity = vector(0, initialVelocity, 0) self.position = vector(planetOrbitRadius, 0, 0) if self.name == 'Earth': self.sphere = sphere(pos=self.position, radius=self.sphereRadius, color=color.blue, make_trail=True, trail_color=color.cyan, retain=maxTrailLength, interval=traceInterval) elif self.name == 'Mars': self.sphere = sphere(pos=self.position, radius=self.sphereRadius, color=color.red, make_trail=True, trail_color=color.orange, retain=maxTrailLength, interval=traceInterval) elif self.name == 'Jupiter': self.sphere = sphere(pos=self.position, radius=self.sphereRadius, color=color.orange, make_trail=True, trail_color=color.red, retain=maxTrailLength, interval=traceInterval) elif self.name == 'Uranus': self.sphere = sphere(pos=self.position, radius=self.sphereRadius, color=color.blue, make_trail=True, trail_color=color.cyan, retain=maxTrailLength, interVal=traceInterval) else: self.sphere = sphere(pos=self.position, radius=self.sphereRadius, color=color.white, make_trail=True, trail_color=color.white, retain=maxTrailLength, interval=traceInterval) else: totalPlanetMomentum = vector(0, 0, 0) positionOffsetThing = 0 for index in range(len(planetObjectList)): localPlanet = planetObjectList[index] totalPlanetMomentum = totalPlanetMomentum + ( localPlanet.mass * localPlanet.velocity) positionOffsetThing = positionOffsetThing + ( localPlanet.mass * localPlanet.position.x) sunPositionOffset = -positionOffsetThing / self.mass self.velocity = -totalPlanetMomentum / self.mass self.position = vector(sunPositionOffset, 0, 0) self.sphere = sphere(pos=self.position, radius=self.sphereRadius, color=color.yellow, make_trail=True, trail_color=color.yellow, retain=maxTrailLength, interval=traceInterval) self.lastStepSign = self.velocity.y / abs(self.velocity.y) if maxTrailLength == -2: self.sphere.make_trail = False
t = linspace(t_start, t_final, n_steps) solu, outodeint = odeint(func, initcond, t, args=(g, l), full_output=True) theta, omega = solu.T # ===================== scene.range = 0.2 # m xp = l * sin(thes) yp = -l * cos(thes) zp = 0. sleeptime = 0.0001 prtcl = sphere(pos=vector(xp, yp, zp), radius=R, color=color.cyan) time_i = 0 t_run = 0 #for i in omega: # print(i) while t_run < t_final: sleep(sleeptime) prtcl.pos = vector(l * sin(theta[time_i]), -l * cos(theta[time_i]), zp) t_run += t_delta time_i += 1
def visual(self): ball=vpy.sphere() for i in range(len(self.theta)): vpy.rate(100) ball.pos.x+=self.t[i] ball.pos.y+=self.theta[i]
colors = [ vpython.color.red, vpython.color.green, vpython.color.blue, vpython.color.yellow, vpython.color.cyan, vpython.color.magenta ] poslist = [] plist = [] mlist = [] rlist = [] for i in range(Nstars): x = L * random.gauss(0, 1) y = L * random.gauss(0, 1) z = L * random.gauss(0, 1) d = math.sqrt(x**2 + y**2 + z**2) r = Rsun star = vpython.sphere(pos=v(x, y, z), radius=r, color=colors[i % 6]) star.trail = vpython.curve(pos=[star.pos], color=colors[i % 6], radius=Rtrail) Stars.append(star) mass = Msun px = mass * vsun * (-1 + 2 * random.random()) * (1 - d / (1.7 * L)) py = mass * vsun * (-1 + 2 * random.random()) * (1 - d / (1.7 * L)) pz = mass * vsun * (-1 + 2 * random.random()) * (1 - d / (1.7 * L)) poslist.append([x, y, z]) plist.append([px, py, pz]) mlist.append(mass) rlist.append(r) pos = numpy.array(poslist) p = numpy.array(plist)
as the speed of the orbits for convenience. Jorge Bustos Feb 17, 2019 """ from __future__ import division, print_function import vpython as vp import numpy as np c1 = 0.0029 #multiplier for the radius of the planets c1_s = 0.00005 #multiplier for the radius of the Sun c2 = 1000 #multiplier for time of the orbit animation Sun = vp.sphere(pos=vp.vector(0, 0, 0), radius=c1_s * 695500, color=vp.color.yellow) Mercury = vp.sphere(pos=vp.vector(57.9, 0, 0), radius=c1 * 2440, color=vp.color.cyan) Venus = vp.sphere(pos=vp.vector(108.2, 0, 0), radius=c1 * 6052, color=vp.color.magenta) Earth = vp.sphere(pos=vp.vector(149.2, 0, 0), radius=c1 * 6371, color=vp.color.blue) Mars = vp.sphere(pos=vp.vector(227.9, 0, 0), radius=c1 * 3386, color=vp.color.red) Jupiter = vp.sphere(pos=vp.vector(778.5, 0, 0), radius=c1 * 69173,
from vpython import vector from copy import copy kinetic = gcurve(color=color.blue) potential = gcurve(color=color.red) energy = gcurve(color=color.black) thermal = gcurve(color=color.green) m = 2 # kg k = 4 # N/m d = 2 t = 0 dt = 0.01 # s s = sphere() spring = helix(radius=0.6, thickness=0.3) s.velocity = vector(-10, 0, 0) s.pos = vector(10, 0, 0) * dt # m s.prev_pos = s.pos - s.velocity * dt # m thermal_energy = 0 while t < 12.0 * pi: kinetic_energy = 0.5 * m * dot(s.velocity, s.velocity) potential_energy = 0.5 * k * dot(s.prev_pos, s.prev_pos) thermal_energy += d * dot(s.velocity, s.velocity) * dt s.force = -k * s.pos - d * s.velocity + 3.0 * sin(1.0 * t) * vector( 1, 0, 0)
import vpython as vp animation_time_step = 0.1 # seconds rate_of_animation = 1 / animation_time_step time_step = 0.05 stop_time = 10. initial_position1 = vp.vector(-5, 0., 0.) initial_velocity1 = vp.vector(1., 0., 0.) ball1 = vp.sphere(pos=initial_position1, radius=0.1, color=vp.color.red, make_trail=True, trail_type="points", trail_radius=0.1) initial_position2 = vp.vector(0., -5., 0.) initial_velocity2 = vp.vector(0., 1., 0.) ball2 = vp.sphere(pos=initial_position2, radius=0.1, color=vp.color.cyan, make_trail=True, trail_type="points", trail_radius=0.1) time = 0. while time < stop_time: vp.rate(rate_of_animation) x = initial_position1.x + initial_velocity1.x * time y = initial_position1.y + initial_velocity1.y * time z = initial_position1.z + initial_velocity1.z * time
height=450, title="Single Simple Pendulum", xtitle="x", ytitle="y", foreground=vp.color.black, background=vp.color.white, stereo="redcyan") # initial_position = vp.vector(-4, 0, 0) initial_velocity = vp.vector(0, 0, 0) # Define Ball/Blob ball = vp.sphere(pos=initial_position, radius=0.5, color=vp.color.cyan, opacity=0.8, make_trail=True, emissive=False) # Define Rod rod = vp.cylinder(pos=initial_position, axis=-ball.pos, radius=0.1) # scene.autoscale = 0 ball.velocity = initial_velocity ball.mass = 0.1 #scene.camera.follow(ball) dt = 0.005 t = 0
# mesh for the orbitrap mesh = Orbitrap_mesh() mesh.plot(-U_r, "inner") mesh.plot(0.0, "outer") # Leap-Frog time integration w = sqrt((q / m) * k) # omega f = w / (2 * pi) dt = 1 / f / kappa I = zeros(N_t) particle = sphere(pos=r, radius=0.5e-3, color=color.green, make_trail=True, retain=100) v -= dt * (q / m) * E(particle.pos) / 2 for i in range(N_t): v += dt * (q / m) * E(particle.pos) particle.pos += dt * v I[i] = v.z / v_phi rate(50) # spectral analysis I_spec = fft(I) m = zeros(N_t) for i in range(1, N_t // 2): w = 2 * pi * i / (N_t * dt)
vp.scene.width = 800 def eval_gravitational_force(p1: vp.sphere, p2: vp.sphere): G = 1 r = p1.pos - p2.pos distance = vp.mag(r) rhat = r / distance force = -rhat * G * p1.mass * p2.mass / distance ** 2 return force star = vp.sphere( pos=vp.vector(0, 0, 0), radius=0.2, color=vp.color.yellow, mass=2.0 * 1000, momentum=vp.vector(0, 0, 0), make_trail=True, ) planets = [ vp.sphere( pos=vp.vector(1, 0, 0), radius=0.05, color=vp.color.green, mass=1, momentum=vp.vector(0, 30, 0), make_trail=True, ), vp.sphere( pos=vp.vector(0, 3, 0),
def plot_vpython(network, Psize='pore.diameter', Tsize='throat.diameter', Pcolor=None, Tcolor=None, cmap='jet', **kwargs): r""" Quickly visualize a network in 3D using VPython. Parameters ---------- network : GenericNetwork The network to visualize. Psize : str (default = 'pore.diameter') The dictionary key pointing to the pore property by which sphere diameters should be scaled Tsize : str (default = 'throat.diameter') The dictionary key pointing to the throat property by which cylinder diameters should be scaled Pcolor : str The dictionary key pointing to the pore property which will control the sphere colors. The default is None, which results in a bright red for all pores. Tcolor : str The dictionary key pointing to the throat property which will control the cylinder colors. The default is None, which results in a unform pale blue for all throats. cmap : str or Matplotlib colormap object (default is 'jet') The color map to use when converting pore and throat properties to RGB colors. Can either be a string indicating which color map to fetch from matplotlib.cmap, or an actual cmap object. kwargs : dict Any additional kwargs that are received are passed to the VPython ``canvas`` object. Default options are: *'height' = 500* - Height of canvas *'width' = 800* - Width of canvas *'background' = [0, 0, 0]* - Sets the background color of canvas *'ambient' = [0.2, 0.2, 0.3]* - Sets the brightness of lighting Returns ------- canvas : VPython Canvas object The canvas object containing the generated scene. The object has several useful methods. Notes ----- **Important** a) This does not work in Spyder. It should only be called from a Jupyter Notebook. b) This is only meant for relatively small networks. For proper visualization use Paraview. """ import matplotlib.pyplot as plt try: from vpython import canvas, vec, sphere, cylinder except ModuleNotFoundError: raise Exception('VPython must be installed to use this function') if isinstance(cmap, str): cmap = getattr(plt.cm, cmap) if Pcolor is None: Pcolor = [vec(230 / 255, 57 / 255, 0 / 255)] * network.Np else: a = cmap(network[Pcolor] / network[Pcolor].max()) Pcolor = [vec(row[0], row[1], row[2]) for row in a] if Tcolor is None: Tcolor = [vec(51 / 255, 153 / 255, 255 / 255)] * network.Nt else: a = cmap(network[Tcolor] / network[Tcolor].max()) Tcolor = [vec(row[0], row[1], row[2]) for row in a] # Set default values for canvas properties if 'background' not in kwargs.keys(): kwargs['background'] = vec(1.0, 1.0, 1.0) if 'height' not in kwargs.keys(): kwargs['height'] = 500 if 'width' not in kwargs.keys(): kwargs['width'] = 800 # Parse any given values for canvas properties for item in kwargs.keys(): try: kwargs[item] = vec(*kwargs[item]) except TypeError: pass scene = canvas(title=network.name, **kwargs) for p in network.Ps: r = network[Psize][p] / 2 xyz = network['pore.coords'][p] c = Pcolor[p] sphere(pos=vec(*xyz), radius=r, color=c, shininess=.5) for t in network.Ts: head = network['throat.endpoints.head'][t] tail = network['throat.endpoints.tail'][t] v = tail - head r = network[Tsize][t] L = np.sqrt(np.sum((head - tail)**2)) c = Tcolor[t] cylinder(pos=vec(*head), axis=vec(*v), opacity=1, size=vec(L, r, r), color=c) return scene
return (m_f) def fza_vect(mag_fza, pos_1, pos_2): vect = mag_fza * vp.hat(pos_2 - pos_1) return (vect) cond_ini(n, rango_masas, longitud, r_ini, v_ini, m_ini) r = [r_ini] v = [v_ini] m = [m_ini] #objetos: planetas = [vp.sphere(pos=i, radius=0.5) for i in r[0]] orbitas = [] for i, j in zip(planetas, masas): i.masa = j #<--- agregamos masa al objeto #for i in planetas: # #trail_i = vp.curve(color = vp.vector(1,0,0)) # -> esto habilitarlo si quiero todos #orbitas.append(trail_i) # trail_i = vp.curve(color=vp.vector(1, 0, 0)) # orbitas.append(trail_i) # -> pa solo 1. #fin objetos ########################################################hacer esto para alterar una masa a placer:
def __setstate__(self, stuff): self.__dict__ = stuff self.vsphere = vp.sphere(color=self.color,\ radius=self.radius)
for i in range(1, num_pts): scan_pts[0][i] = (inc * cos(scan_angle) + scan_pts[0][i - 1]) * 1 scan_pts[1][i] = (inc * sin(scan_angle) + scan_pts[1][i - 1]) * 1 scan_pts[2][i] = -(sqrt(rpv_r ** 2 - scan_pts[1][i] ** 2) - h) vp.scene.camera.pos = vp.vector(scan_pts[0][num_pts - 1], scan_pts[1][num_pts - 1], scan_pts[2][num_pts - 1]) # Loop through scan points for j in range(num_pts): j2, j3, j4, pvt, ee = c_jpos(scan_pts[:, j]) t1, t2, t3, t4 = c_angles(scan_pts[:, j]) # Check if end effector is in the scan location if round(float(scan_pts[0, j]), 4) != round(float(ee[0]), 4) or round(float(scan_pts[1, j]), 4) != round( float(ee[1]), 4) or round(float(scan_pts[2, j]), 4) != round(float(ee[2]), 4): print("ERROR POSITION %2.2f %2.2f %2.2f" % (ee[0], ee[1], ee[2])) # Print the calculated results print("%2.2f %2.2f %2.2f %2.2f %2.2f %2.2f %2.2f %2.2f %2.2f %2.2f " % ( scan_pts[0, j], scan_pts[1, j], scan_pts[2, j], rad2deg(t1), rad2deg(t2), rad2deg(t3), rad2deg(t4), ee[0], ee[1], ee[2])) # Visual Python: Show scan points in green and the manipulator as a grey curve vp.sphere(pos=vp.vector(scan_pts[0, j], scan_pts[1, j], scan_pts[2, j]), color=vp.color.green, radius=0.1) vp.curve( pos=[(0, 0, 0), (j2[0], j2[1], j2[2]), (j3[0], j3[1], j3[2]), (j4[0], j4[1], j4[2]), (pvt[0], pvt[1], pvt[2]), (ee[0], ee[1], ee[2])], radius=0.05) time.sleep(.02)
scene.width = 1200 # Ajustando a largura da cena scene.height = 1000 # Ajustando a altura da cena scene.camera.pos = vector(2, -1, 2) scene.camera.axis = vector(-2, 1, -2) suporte = box(pos=vector(.0, .05, .0), up=vector(.0, 1., .0), length=2, height=.1, width=2, texture=textures.wood) # Suporte mola = helix(pos=vector(0, 0, 0), axis=vector(*r_vrl), color=color.yellow, radius=.03) # Mola do pendulo bola = sphere(axis=vector(*r_vrl), radius=.1, make_trail=True) # Bola # Constantes C = 1. while t <= b: rate(C / h) mola.axis = vector(*r_vrl) bola.pos = vector(*r_vrl) r_vrl, v_vrl, vpm = passo_vrl(f, r_vrl, v_vrl, vpm, t, h) t += h
myLabel = myText[myLine].strip() myLabels.append(myLabel) myLine += 1 myConceptLoopCounter += 1 print("myConceptCount is ", myConceptCount) print("Labels are ", myLabels) myNormalize() a = vp.canvas( title='Simple Galileo Viewer by Rob Zimmelman c. 2018 All Rights Reserved', width=1400, height=700, background=vp.color.black) myBox = vp.box(length=200, width=200, height=0.01, opacity=0.5) for i in range(0, myConceptCount): print(i, x[i], y[i], z[i]) a = vp.sphere(pos=vp.vector(xNorm[i], yNorm[i], zNorm[i]), color=vp.color.red, radius=1.0) b = vp.label(text=myLabels[i], pos=vp.vector(xNorm[i], yNorm[i], zNorm[i]), color=vp.color.yellow, box=True, line=True, xoffset=75, yoffset=15, radius=12.0) c = vp.arrow(pos=vp.vector(xNorm[i], 0, zNorm[i]), color=vp.color.blue, shaftwidth=0.25, axis=vp.vector(0, yNorm[i], 0))
t = linspace(t_start, t_final, n_steps)#arreglo de diferencial de tiempo solu, outodeint = odeint( 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 = 1 # 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) #Definimos la esfera 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( ll[time_i]*sin(theta[time_i]), -ll[time_i]*cos(theta[time_i]), zp ) t_run += t_delta time_i += 1
k3 = h*f(r+0.5*k2, t+0.5*h) k4 = h*f(r+k3, t+h) r += (k1+2*k2+2*k3+k4)/6 print(0.5*(t/len(pontstemp))*10000.0,"%") #Preparando modo gráfico #Realizando o modo gráfico from vpython import sphere,canvas,color,vector,cylinder,box,helix,rate #Configuração da janela scene2 = canvas(title = "Simulação de órbitas caóticas", width = 600, height = 600,background=color.white) esferabola1 = sphere(radius=7,pos=vector(x1,y1,0),color=color.yellow) esferabola2 = sphere(radius=2,pos=vector(x2,y2,0),color=color.red) esferabola3 = sphere(radius=2,pos=vector(x3,y3,0),color=color.blue) cont = 0 T = len(pontstemp) for k in range(T): esferabola1.pos = vector(posicaox1[k],posicaoy1[k],0.0) esferabola2.pos = vector(posicaox2[k],posicaoy2[k],0.0) esferabola3.pos = vector(posicaox3[k],posicaoy3[k],0.0) cont = cont + 1 if (cont == 100): sphere(radius=1.0,pos=vector(posicaox2[k],posicaoy2[k],0),color=color.red)
r += (k1 + 2 * k2 + 2 * k3 + k4) / 6 # plot(tpoints, theta1_points,'b') # plot(tpoints, theta2_points, 'g') # plot(tpoints, energy_points) # xlabel('t (s)') # ylabel('energy (J)') # show() # Make animation rod1 = cylinder(pos=vector(0, 0, 0), axis=vector(l * cos(theta1_0 - pi / 2), l * sin(theta1_0 - pi / 2), 0), radius=l / 40) bob1 = sphere(pos=vector(l * cos(theta1_0 - pi / 2), l * sin(theta1_0 - pi / 2), 0), radius=l / 10) rod2 = cylinder(pos=vector(l * cos(theta1_0 - pi / 2), l * sin(theta1_0 - pi / 2), 0), \ axis=vector(l * cos(theta2_0 - pi / 2), l * sin(theta2_0 - pi / 2), 0), radius=l/40) bob2 = sphere(pos=vector(l * cos(theta2_0 - pi / 2), l * sin(theta2_0 - pi / 2), 0), radius=l / 10) for i in range(N): rate(N // 100) vector1 = vector(l * cos(theta1_points[i] - pi / 2), l * sin(theta1_points[i] - pi / 2), 0) vector2 = vector(l * cos(theta2_points[i] - pi / 2), l * sin(theta2_points[i] - pi / 2), 0) rod1.axis = vector1 bob1.pos = vector1
"masa_anillo": 1, } dt = 0.01 t_max = 10 t = 0 ka = 1 Particulas_libres = [] Particulas_anillo = [] #posiciones de discretizacion del anillo for i in range(cond_ini["num_parts_anillo"]): p_0 = (cond_ini["radio_anillo"]) * vp.vector( np.cos((2 * np.pi * i) / (cond_ini["num_parts_anillo"])), np.sin((2 * np.pi * i) / (cond_ini["num_parts_anillo"])), 0) part_i = vp.sphere(pos=p_0, radius=0.3, color=vp.vector(1, 1, 1)) part_i.carga = cond_ini["carga_anillo"] part_i.momento = vp.vector(0, 0, 0) Particulas_anillo.append(part_i) #partículas dentro for i in range(cond_ini["num_parts_dentro"]): r_part = np.linspace(0, cond_ini["radio_anillo"] * 0.75, 100) theta_part = np.linspace(0, 2 * np.pi, 100) r_i = rand.choice(r_part) theta_i = rand.choice(theta_part) p_0 = r_i * (vp.vector(np.cos(theta_i), np.sin(theta_i), 0)) part_i = vp.sphere(pos=p_0, radius=0.3, color=vp.vector(1, 0, 1)) #pa vels vel_part = np.linspace(cond_ini["v_min"], cond_ini["v_max"], 100) vel_i = vp.vector(rand.choice(vel_part), rand.choice(vel_part), 0) part_i.vel = vel_i
#initialize the position array: r = np.array([th0, om0], float) # RK4 algorithm for t in tp: thp.append(r[0]) omp.append(r[1]) k1 = h * f(r, t) k2 = h * f(r + 0.5 * k1, t + 0.5 * h) k3 = h * f(r + 0.5 * k2, t + 0.5 * h) k4 = h * f(r + k3, t + h) r += (k1 + 2 * k2 + 2 * k3 + k4) / 6 mp.title('Phasee Portrait of a Pendulum') mp.plot(thp, omp) mp.xlabel(r'Angle $(Rads)$') mp.ylabel(r'Angular Velocity $(\frac{Rads}{s})$') mp.show() # make animation rod = cylinder(pos=vector(0, 0, 0), axis=vector(l * np.cos(th0 - pi / 2), l * np.sin(th0 - pi / 2), 0), radius=l / 40) bob = sphere(pos=vector(l * np.cos(th0 - pi / 2), l * np.sin(th0 - pi / 2), 0), radius=l / 10) for theta in thp: rate(N // 10) rod.axis = vector(l * np.cos(theta - pi / 2), l * np.sin(theta - pi / 2), 0) bob.pos = vector(l * np.cos(theta - pi / 2), l * np.sin(theta - pi / 2), 0)
''' Created on 8 juil. 2012 @author: Laurent ''' from vpython import box, sphere, vector, color, rate floor = box(pos=vector(0, 0, 0), length=4, height=0.5, width=4, color=color.blue) ball = sphere(pos=vector(0, 4, 0), radius=1, color=color.red) ball.velocity = vector(0, -1, 0) dt = 0.01 while 1: rate(100) ball.pos = ball.pos + ball.velocity * dt if ball.pos.y < ball.radius: ball.velocity.y = abs(ball.velocity.y) else: ball.velocity.y = ball.velocity.y - 9.8 * dt
import vpython as vp import serial import time from math import * ser = serial.Serial('/dev/ttyUSB0', 9600, timeout=3) print(ser.name) scene = vp.canvas() scene.background = vp.color.gray(.2) head_main = vp.ellipsoid(pos=vp.vector(0, .85, 0), length=1.3, width=1.3, height=1.7, color=vp.vector(.9, .7, .5)) left_eye = vp.sphere(pos=vp.vector(-.25, 1, .5), radius=.15, color=vp.vector(0, 0, 0)) right_eye = vp.sphere(pos=vp.vector(.25, 1, .5), radius=.15, color=vp.vector(0, 0, 0)) head = vp.compound([head_main, left_eye, right_eye]) for i in range(5): print(ser.readline()) old_theta = 0 old_phi = 0 while 1: read = ser.readline().decode("utf-8").split() x = float(read[1]) y = float(read[3]) z = float(read[5])