def __init__(self):
self.sphereList = [] #sphere for each node
self.rodList = [] #unused
self.manageRodList = [
] #rods connecting nodes to centre management node
r = 1.0 #radius of circle that nodes are in
delta_theta = (2.0 * math.pi) / G.NUMNODES #angle between nodes
theta = 0
self.management = v.sphere(
pos=v.vector(0, 0, 0), radius=0.1,
colour=v.color.blue) #management node in centre
self.label = v.label(
pos=(1, 1, 0),
text='0') #label for amount of disparities at that point in time
self.label_cum = v.label(pos=(-1, 1, 0),
text='0') #cumulative total number of above
for i in range(0, G.NUMNODES):
circ = v.sphere(pos=v.vector(r * math.cos(theta),
r * math.sin(theta), 0),
radius=0.1,
color=v.color.green)
self.sphereList.append(circ)
print 'circle no. ', i, ' coords ', r * math.cos(
theta), ' ', r * math.sin(theta)
theta += delta_theta
rod = v.cylinder(pos=(0, 0, 0),
axis=(self.sphereList[i].pos),
radius=0.005,
color=v.color.white)
self.manageRodList.append(rod)
def go():
r = np.array([1.017, 0.0]) # initial x,y position for earth
v = np.array([0.0, 6.179]) # initial vx, vy
# draw the scene, planet earth/path, sun/sunlight
scene = vp.display(
title='Planetary motion', # scene start
background=(.2, .5, 1),
forward=(0, 2, -1))
planet = vp.sphere(pos=r,
radius=0.1,
make_trail=True,
material=vp.materials.earth,
up=(0, 0, 1))
sun = vp.sphere(pos=(0, 0),
radius=0.2,
color=vp.color.yellow,
material=vp.materials.emissive)
sunlight = vp.local_light(pos=(0, 0), color=vp.color.yellow) #scn end
t, h = 0.0, 0.001
while True:
vp.rate(200) # limit animation speed
r, v = ode.leapfrog(earth, r, v, t, h) # integrate
planet.pos = r # move planet
if (scene.kb.keys): scene.kb.getkey(), scene.kb.getkey() #pause
def show_protective(nparticles):
# create scene
scene = visual.display(title='Protective zones', width=600, height=400, center=(0,0,0))
scene.select()
# read in positions, state and protective zones
positions = (numpy.genfromtxt('position.dat'))[:nparticles]
state = (numpy.genfromtxt('state.dat'))[:nparticles]
zones = (numpy.genfromtxt('fpt.dat'))[:nparticles]
# go through particles and display them
for i in range(nparticles):
# color the spheres according to state
cball = visual.color.green
if (state[i,0]==1):
cball = visual.color.red
else:
cball = visual.color.blue
if (state[i,3]==1):
cball = visual.color.yellow
if (state[i,3]==2):
cball = visual.color.orange
visual.sphere(pos=(positions[i,0], positions[i,1], positions[i,2]), radius=zones[i], color=cball)
visual.label(pos=(positions[i,0], positions[i,1], positions[i,2]), text='{0:d}'.format(i))
def show_ladybug(self, H=None):
'''Show Ladybug in Visual Python at origin or at the translated position
if parameter is given.
TODO: Implement an additional translation H and show at new position.'''
# vis.ellipsoid(width=0.12, length=0.08, height=0.08,
# color=vis.color.red, opacity=0.2)
vis.arrow(axis=(0.04, 0, 0), color=(1,0,0) )
vis.arrow(axis=(0, 0.04, 0), color=(0,1,0) )
vis.arrow(axis=(0, 0, 0.04), color=(0,0,1) )
colors = [vis.color.red, vis.color.green, vis.color.blue,
vis.color.cyan, vis.color.yellow, vis.color.magenta]
for P in self.LP:
R = P[:3,:3]
pos = dot(P[:3],r_[0,0,0,1])
pos2 = dot(P[:3],r_[0,0,0.01,1])
vis.sphere(pos=pos, radius=0.002, color=colors.pop(0))
vis.box(pos=pos2, axis=dot(R, r_[0,0,1]).flatten(),
size=(0.001,0.07,0.09), color=vis.color.red,
opacity=0.1)
vis.arrow(pos=pos,
axis=dot(R, r_[0.02,0,0]).flatten(),
color=(1,0,0), opacity=0.5 )
vis.arrow(pos=pos,
axis=dot(R, r_[0,0.02,0]).flatten(),
color=(0,1,0), opacity=0.5 )
vis.arrow(pos=pos,
axis=dot(R, r_[0,0,0.02]).flatten(),
color=(0,0,1), opacity=0.5 )
def Ch3_Prob5(time): base = 57.9#base for distance from the sun. (x = 1 means 57.9 km ) rad_base = 10*2440#base for the radius of the planets size of each #Per_base = 88# base for the period sun = sphere(pos = [0,0,0], radius = .5) mercu = sphere(pos = [(57.90/base), 0, 0], radius = (2440.0/rad_base)) venus = sphere(pos = [(108.2/base), 0, 0], radius = (6052.0/rad_base)) earth = sphere(pos = [(149.6/base), 0, 0], radius = (6371.0/rad_base)) marss = sphere(pos = [(227.6/base), 0, 0], radius = (3386.0/rad_base)) #frequencies Fmerc = 2*pi/88 Fvenu = 2*pi/224.7 Feart = 2*pi/365.3 Fmars = 2*pi/687.0 #colors sun.color = color.yellow mercu.color = color.gray(0.5) earth.color = color.blue marss.color = color.red for t in arange(0,time,0.01): #print t rate(100) mercu.pos = [(57.90/base)*cos(Fmerc*t), (57.90/base)*sin(Fmerc*t), 0] venus.pos = [(108.2/base)*cos(Fvenu*t), (108.2/base)*sin(Fvenu*t), 0] earth.pos = [(149.6/base)*cos(Feart*t), (149.6/base)*sin(Feart*t), 0] marss.pos = [(227.6/base)*cos(Fmars*t), (227.6/base)*sin(Fmars*t), 0] return 'done'
def draw_node_list(self, radius=2.0):
if self._nodes == None:
print "ERROR: you have to set/load node list before drawing them."
exit(1)
for i in range(1,len(self._nodes)):
x, y = self._nodes[i][0], self._nodes[i][1]
vs.sphere(display=self.route_window, pos=vs.vector(x,y,0),
radius=radius, color=vs.color.blue)
def sphere():
from visual import sphere,color
L = 5
R = 0.3
for i in range(-L,L+1):
for j in range(-L,L+1):
for k in range(-L,L+1):
sphere(pos=[i,j,k],radius=R,color=color.blue)
def main():
from visual import sphere
L = 5
R = 0.3
for i in range(-L, L + 1):
for j in range(-L, L + 1):
for k in range(-L, L + 1):
sphere(pos=[i, j, k], radius=R)
def set_scene(r): # r = position of test body
vp.display(title='Restricted 3body', background=(1,1,1))
body = vp.sphere(pos=r, color=(0,0,1), radius=0.03, make_trail=1)
sun = vp.sphere(pos=(-a,0), color=(1,0,0), radius=0.1)
jupiter = vp.sphere(pos=(b, 0), color=(0,1,0), radius=0.05)
circle = vp.ring(pos=(0,0), color=(0,0,0), thickness=0.005,
axis=(0,0,1), radius=1) # unit circle
return body
def main():
if len(argv) < 3:
raise Exception('>>> ERROR! Please supply values for black hole mass [>= 1.0] and spin [0.0 - 1.0] <<<')
m = float(argv[1])
a = float(argv[2])
horizon = m * (1.0 + sqrt(1.0 - a * a))
cauchy = m * (1.0 - sqrt(1.0 - a * a))
# set up the scene
scene.center = (0.0, 0.0, 0.0)
scene.width = scene.height = 1024
scene.range = (20.0, 20.0, 20.0)
inner = 2.0 * sqrt(cauchy**2 + a**2)
ellipsoid(pos = scene.center, length = inner, height = inner, width = 2.0 * cauchy, color = color.blue, opacity = 0.4) # Inner Horizon
outer = 2.0 * sqrt(horizon**2 + a**2)
ellipsoid(pos = scene.center, length = outer, height = outer, width = 2.0 * horizon, color = color.blue, opacity = 0.3) # Outer Horizon
ergo = 2.0 * sqrt(4.0 + a**2)
ellipsoid(pos = scene.center, length = ergo, height = ergo, width = 2.0 * horizon, color = color.gray(0.7), opacity = 0.2) # Ergosphere
if fabs(a) > 0.0:
ring(pos=scene.center, axis=(0, 0, 1), radius = a, color = color.white, thickness=0.01) # Singularity
else:
sphere(pos=scene.center, radius = 0.05, color = color.white) # Singularity
ring(pos=scene.center, axis=(0, 0, 1), radius = sqrt(isco(a)**2 + a**2), color = color.magenta, thickness=0.01) # ISCO
curve(pos=[(0.0, 0.0, -15.0), (0.0, 0.0, 15.0)], color = color.gray(0.7))
#cone(pos=(0,0,12), axis=(0,0,-12), radius=12.0 * tan(0.15 * pi), opacity=0.2)
#cone(pos=(0,0,-12), axis=(0,0,12), radius=12.0 * tan(0.15 * pi), opacity=0.2)
#sphere(pos=(0,0,0), radius=3.0, opacity=0.2)
#sphere(pos=(0,0,0), radius=12.0, opacity=0.1)
# animate!
ball = sphere() # Particle
counter = 0
dataLine = stdin.readline()
while dataLine: # build raw data arrays
rate(60)
if counter % 1000 == 0:
ball.visible = False
ball = sphere(radius = 0.2) # Particle
ball.trail = curve(size = 1) # trail
data = loads(dataLine)
e = float(data['v4e'])
if e < -120.0:
ball.color = color.green
elif e < -90.0:
ball.color = color.cyan
elif e < -60.0:
ball.color = color.yellow
elif e < -30.0:
ball.color = color.orange
else:
ball.color = color.red
r = float(data['r'])
th = float(data['th'])
ph = float(data['ph'])
ra = sqrt(r**2 + a**2)
sth = sin(th)
ball.pos = (ra * sth * cos(ph), ra * sth * sin(ph), r * cos(th))
ball.trail.append(pos = ball.pos, color = ball.color)
counter += 1
dataLine = stdin.readline()
def marks(self):
marks_list = []
new_time = self.time
while new_time >= 5:
marks_list.append(int(new_time))
new_time = new_time - 5.0
marks_list.append(int(0))
for marks in marks_list:
sphere(pos=(marks, marks * 1.1, 0), radius=0, label=str(marks) + " seconds")
def __init__(self, joint, num, length, height=LEGS_HEIGHT, width=LEGS_WIDTH):
"""
"""
super(Tars3D, self).__init__(joint, num, length, height, width, (0, 0, 1))
visual.cylinder(frame=self, pos=(0, 0, -(width+5)/2), radius=(height+1)/2, axis=(0, 0, 1), length=width+5, color=visual.color.cyan)
visual.box(frame=self, pos=((length-5)/2, 0, 0), length=length-5/2, height=height, width=width , color=visual.color.yellow)
visual.sphere(frame=self, pos=(length-5/2, 0, 0), radius=5)
self.rotate(angle=math.radians(180), axis=self._axis)
def set_scene(R, r): # create bodies, velocity arrows
vp.display(title='Three-body motion', background=(1,1,1))
body, vel = [], [] # bodies, vel arrows
c = [(1,0,0), (0,1,0), (0,0,1), (0,0,0)] # RGB colors
for i in range(3):
body.append(vp.sphere(pos=r[i],radius=R,color=c[i],make_trail=1))
vel.append(vp.arrow(pos=body[i].pos,shaftwidth=R/2,color=c[i]))
line, com = vp.curve(color=c[3]), vp.sphere(pos=(0,0), radius=R/4.)
return body, vel, line
def set_scene(R, r): # create bodies, velocity arrows
vp.display(title='Three-body motion', background=(1, 1, 1))
body, vel = [], [] # bodies, vel arrows
c = [(1, 0, 0), (0, 1, 0), (0, 0, 1), (0, 0, 0)] # RGB colors
for i in range(3):
body.append(vp.sphere(pos=r[i], radius=R, color=c[i], make_trail=1))
vel.append(vp.arrow(pos=body[i].pos, shaftwidth=R / 2, color=c[i]))
line, com = vp.curve(color=c[3]), vp.sphere(pos=(0, 0), radius=R / 4.)
return body, vel, line
def draw_node_list(self, radius=2.0):
if self._nodes == None:
print "ERROR: you have to set/load node list before drawing them."
exit(1)
for i in range(1, len(self._nodes)):
x, y = self._nodes[i][0], self._nodes[i][1]
vs.sphere(display=self.route_window,
pos=vs.vector(x, y, 0),
radius=radius,
color=vs.color.blue)
def addSmallSphere(self, point, colour=None, opacity=1., material=None):
if not VISUAL_INSTALLED:
return
if colour == None:
colour = visual.color.blue
visual.sphere(pos=point,
radius=0.00012,
color=geo.norm(colour),
opacity=opacity,
materiall=material)
def __init__(self, color=None, *args, **kwargs):
""" Init CoordinatesSystem3D object
"""
super(CoordinatesSystem3D, self).__init__(*args, **kwargs)
if color is None:
visual.sphere(frame=self, radius=3, color=visual.color.gray(0.5))
visual.arrow(frame=self, axis=(1, 0, 0), length=30, color=visual.color.cyan)
visual.arrow(frame=self, axis=(0, 0, -1), length=30, color=visual.color.magenta)
visual.arrow(frame=self, axis=(0, 1, 0), length=30, color=visual.color.yellow)
def create_cube():
visual.scene.range = (256, 256, 256)
visual.scene.center = (128, 128, 128)
t = range(0, 256, 51)
for x in t:
for y in t:
for z in t:
pos = x, y, z
color = (x / 255.0, y / 255.0, z / 255.0)
visual.sphere(pos=pos, radius=10, color=color)
def create_color_cube():
visual.scene.range = (256, 256, 256)
visual.scene.center = (128, 128, 128)
color_dict, rgbs = color_list.read_colors()
for rgb in color_dict.values():
r = int(rgb[1:3], 16)
g = int(rgb[3:5], 16)
b = int(rgb[5:7], 16)
pos = (r, g, b)
color = (r / 255.0, g / 255.0, b / 255.0)
visual.sphere(pos=pos, radius=10, color=color)
def set_scene(r): # r = position of test body
vp.display(title='Restricted 3body', background=(1, 1, 1))
body = vp.sphere(pos=r, color=(0, 0, 1), radius=0.03, make_trail=1)
sun = vp.sphere(pos=(-a, 0), color=(1, 0, 0), radius=0.1)
jupiter = vp.sphere(pos=(b, 0), color=(0, 1, 0), radius=0.05)
circle = vp.ring(pos=(0, 0),
color=(0, 0, 0),
thickness=0.005,
axis=(0, 0, 1),
radius=1) # unit circle
return body
def create_color_cube():
visual.scene.range=(256,256,256)
visual.scene.center=(128,128,128)
color_dict,rgbs=color_list.read_colors()
for rgb in color_dict.values():
r=int(rgb[1:3],16)
g=int(rgb[3:5],16)
b=int(rgb[5:7],16)
pos=(r,g,b)
color=(r/255.0,g/255.0,b/255.0)
visual.sphere(pos=pos,radius=10,color=color)
def marks(self):
marks_list = []
new_time = self.time
while (new_time >= 5):
marks_list.append(int(new_time))
new_time = new_time - 5.0
marks_list.append(int(0))
for marks in marks_list:
sphere(pos=(marks, marks * 1.1, 0),
radius=0,
label=str(marks) + ' seconds')
def addSphere(self, sphere, colour=None, opacity=1., material=None):
"""docstring for addSphere"""
if not Visualiser.VISUALISER_ON:
return
if isinstance(sphere, geo.Sphere):
if colour == None:
colour = visual.color.red
if np.allclose(np.array(colour), np.array([0,0,0])):
visual.sphere(pos=sphere.centre, radius=sphere.radius, opacity=opacity, material=material)
else:
visual.sphere(pos=sphere.centre, radius=sphere.radius, color=geo.norm(colour), opacity=opacity, material=material)
def PlotElevator(filename):
try:
f = open(filename,'r')
data = json.loads(f.read())
f.close()
except Exception as e:
return str(e)
print(data["L0"])
pos = []
for i in range(data["SavedSteps"]):
if not None in [elem for s1 in data["Position"][i] for elem in s1]:
pos.append(data["Position"][i])
else:
break
pos = array(pos)
vel = array(data["Velocity"])
scene = vs.display(title='3D representation', x=500, y=0, width=1920, height=1080, background=(0,0,0), center=pos[0][-1])
string = vs.curve(pos=pos[0], radius=50)
earth = vs.sphere(radius=R_earth_equator)
asteroid = vs.sphere(pos=pos[0][-1],radius=1e3, color=vs.color.red)
anchor = vs.sphere(pos=pos[0][0],radius=1e2, color=vs.color.green)
label_avg_l0 = vs.label(pos=pos[0][-1], text="t: %3.1f" % (data["Time"][0],))
body = 1
nt = 0
while True:
vs.rate(60)
if scene.kb.keys: # event waiting to be processed?
s = scene.kb.getkey() # get keyboard info
if s == "d":
if body == -1:
body = 0
elif body == 0:
body = 1
else:
body = -1
if body == 1:
scene.center = (0,0,0)
else:
scene.center = pos[nt][body]
string.pos=pos[nt]
asteroid.pos=pos[nt][-1]
anchor.pos=pos[nt][0]
label_avg_l0.pos = asteroid.pos
label_avg_l0.text = "t: %3.1f" % (data["Time"][nt],)
if nt + 1 >= pos.shape[0]:
nt = 0
else:
nt += 1
def set_scene(r): # r = init position of planet
# draw scene, mercury, sun, info box, Runge-Lenz vector
scene = vp.display(title='Precession of Mercury',
center=(.1*0,0), background=(.2,.5,1))
planet= vp.sphere(pos=r, color=(.9,.6,.4), make_trail=True,
radius=0.05, material=vp.materials.diffuse)
sun = vp.sphere(pos=(0,0), color=vp.color.yellow,
radius=0.02, material=vp.materials.emissive)
sunlight = vp.local_light(pos=(0,0), color=vp.color.yellow)
info = vp.label(pos=(.3,-.4), text='Angle') # angle info
RLvec = vp.arrow(pos=(0,0), axis=(-1,0,0), length = 0.25)
return planet, info, RLvec
def create_cube():
visual.scene.range=(256,256,256)
visual.scene.center=(128,128,128)
t=range(0,256,51)
for x in t:
for y in t:
for z in t:
pos=x,y,z
color=(x/255.0,y/255.0,z/255.0)
visual.sphere(pos=pos,radius=10,color=color)
def addSmallSphere(self, point, colour=None, opacity=1.0):
if not Visualiser.VISUALISER_ON:
return
if colour is None:
colour = visual.color.blue
try:
colour = visual.vec(*colour)
except TypeError:
pass
point = tuple(point)
pos = visual.vec(*point)
visual.sphere(pos=pos, radius=0.00012, color=norm(colour), opacity=opacity)
def addSphere(self, sphere, colour=None, opacity=1.):
"""docstring for addSphere"""
if not Visualiser.VISUALISER_ON:
return
if isinstance(sphere, Sphere):
if colour == None:
colour = visual.color.red
if np.allclose(np.array(colour), np.array([0,0,0])):
visual.sphere(pos=visual.vec(sphere.centre), radius=sphere.radius, opacity=opacity)
else:
visual.sphere(pos=visual.vec(sphere.centre), radius=sphere.radius, color=norm(colour), opacity=opacity)
def addSphere(self, sphere, colour=None, opacity=1., material=visual.materials.plastic):
"""docstring for addSphere"""
if not Visualiser.VISUALISER_ON:
return
if isinstance(sphere, geo.Sphere):
if colour == None:
colour = visual.color.red
if np.allclose(np.array(colour), np.array([0,0,0])):
visual.sphere(pos=sphere.centre, radius=sphere.radius, opacity=opacity, material=material)
else:
visual.sphere(pos=sphere.centre, radius=sphere.radius, color=geo.norm(colour), opacity=opacity, material=material)
def generate_obstacles(n): from random import randint obstacles = [] for i in range(n): x = randint(RADIUS, WIDTH - RADIUS) y = randint(RADIUS, LENGTH - RADIUS) obstacles.append( (x, y) ) sphere(pos = vector(x, RADIUS, y), radius = RADIUS, color = color.red) return obstacles
def render_updates(self):
if self.object is None:
return
if abs(self.last_trail_at -
PhysicalObject.get_total_time()) > TRAIL_AFTER_TIME:
# if(self.trail_count >= NUM_TRAILS)
sphere(pos=self.object.pos,
radius=RADIUS_TRAIL,
color=self.object.color)
# print("Trail created")
self.last_trail_at = PhysicalObject.get_total_time()
self.object.pos = self.get_scaled_pos()
def sodium_chloride(side):
from visual import sphere,color
from numpy import sqrt,array
sodium_r = 190
chloride_r = 79
rbigger = max(sodium_r,chloride_r)
rsmaller = min(sodium_r,chloride_r)
sodium_big = sodium_r == rbigger
spacing = (rsmaller+rbigger)
sodium_color = color.red
chloride_color = color.green
for x in range(side):
for y in range(side):
for z in range(side):
sphere(pos=2*spacing*array([x,y,z]),
radius=sodium_r if sodium_big else chloride_r,
color=sodium_color if sodium_big else chloride_color)
sphere(pos=2*spacing*array([x+.5,y,z]),
radius=chloride_r if sodium_big else sodium_r,
color=chloride_color if sodium_big else chloride_color)
sphere(pos=2*spacing*array([x,y+.5,z]),
radius=chloride_r if sodium_big else sodium_r,
color=chloride_color if sodium_big else chloride_color)
sphere(pos=2*spacing*array([x,y,z+.5]),
radius=chloride_r if sodium_big else sodium_r,
color=chloride_color if sodium_big else chloride_color)
def draw_spatial_center(mol):
xyz = [0, 0, 0]
tot = 0
for at in mol.atoms:
tot += at.mass
for at in mol.atoms:
c = at.mass
xyz[0] += at.x * c
xyz[1] += at.y * c
xyz[2] += at.z * c
xyz[0] /= tot
xyz[1] /= tot
xyz[2] /= tot
sphere(pos=xyz, radius=0.5, color=color.blue)
def draw_spatial_center(mol):
xyz = [0,0,0]
tot = 0
for at in mol.atoms:
tot+= at.mass
for at in mol.atoms:
c = at.mass
xyz[0] += at.x*c
xyz[1] += at.y*c
xyz[2] += at.z*c
xyz[0]/= tot
xyz[1]/= tot
xyz[2]/= tot
sphere(pos= xyz,radius=0.5,color=color.blue)
def sCaidalibre(self):
self.alturaCL=self.alturaCL.get()
self.velocidadX=self.velocidadX.get()
try:
self.alturaCL=float(self.alturaCL)
self.velocidadX=float(self.velocidadX)
except:
self.alerta()
gdpos=vgraph.gdisplay(x=600,y=0,xtitle='Tiempo',ytitle='Posicion(y)')
plotpos=vgraph.gcurve(gdisplay=gdpos,color=vs.color.red)
gdvel=vgraph.gdisplay(x=600,y=600,xtitle='Velocidad',ytitle='Tiempo')
plotvel=vgraph.gcurve(gdisplay=gdvel,color=vs.color.blue)
gdacl=vgraph.gdisplay(x=0,y=900,xtitle='Aceleracion',ytitle='Tiempo')
plotacl=vgraph.gcurve(gdisplay=gdacl,color=vs.color.blue)
suelo=vs.box(pos=(0,-5,0),length=30,height=0.1,width=1,color=vs.color.blue)
esferaC=vs.sphere(pos=(0,self.alturaCL,-2),radius=1,color=vs.color.red)
T=np.sqrt(2*(self.alturaCL+5)/9.8)
t=0
while t<T:
esferaC.pos=(self.velocidadX*t,self.alturaCL-9.8*t**2/2,-2)
plotpos.plot(pos=(t,self.alturaCL-9.8*t**2/2))
plotvel.plot(pos=(t,-9.8*t))
plotacl.plot(pos=(t,-9.8))
t+=0.001
vs.rate(100)
def draw_axes():
global x_axis,y_axis,z_axis,axis_ball
if x_axis:
x_axis.visible=False
x_axis=None
if y_axis:
y_axis.visible=False
y_axis=None
if z_axis:
z_axis.visible=False
z_axis=None
if axis_ball:
axis_ball.visible=False
axis_ball=None
if not axis_enabled:
return
use_x=min_x!=max_x
use_y=min_y!=max_y
use_z=min_z!=max_z
zero_coord=(min_x / (min_x - max_x),min_y / (min_y - max_y),min_z / (min_z - max_z))
if use_x:
x_axis = visual.arrow(pos=zero_coord, axis=(.3,0,0), shaftwidth=0.01, color=visual.color.red)
if use_y:
y_axis = visual.arrow(pos=zero_coord, axis=(0,.3,0), shaftwidth=0.01, color=visual.color.green)
if use_z:
z_axis = visual.arrow(pos=zero_coord, axis=(0,0,.3), shaftwidth=0.01, color=visual.color.blue)
axis_ball = visual.sphere(pos=zero_coord, radius=.02, color=visual.color.yellow)
def run(self):
'''
Run the simulation with racers that had been previously added to the world
by add_racer method.
'''
# create the scene with the plane at the top
visual.scene.center = visual.vector(0,-25,0)
visual.box(pos=(0,0,0), size=(12,0.2,12), color=visual.color.green)
# create the visual objects that represent the racers (balls)
balls = [ visual.sphere(pos=(index,0,0), radius=0.5) for index in xrange(len(self.racers))]
for ball, racer in zip(balls, self.racers):
color = visual.color.blue
try:
# try to set the color given by a string
color = getattr(visual.color, racer.color)
except AttributeError:
pass
ball.trail = visual.curve(color=color)
while not reduce(lambda x, y: x and y, [racer.result for racer in self.racers]):
# slow down the looping - allow only self.time_calibration
# number of loop entries for a second
visual.rate(self.time_calibration)
# move the racers
for racer in self.racers:
self.__move_racer(racer)
for ball, racer in zip(balls, self.racers):
ball.pos.y = -racer.positions[-1][1]
ball.pos.x = racer.positions[-1][0]
ball.trail.append(pos=ball.pos)
self.current_time += self.interval
self.timeline.append(self.current_time)
def Ch3_Exa3(): s = sphere(pos=[1,0,0],radius=0.1) for theta in arange(0,10*pi,0.1): rate(1) x= cos(theta) y = sin (theta) s.pos = [x,y,0]
def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):
""" Calculate the trajectory of a baseball including air resistance and spin by
repeatedly calling the do_time_step function. Also draw the trajectory using visual python. """
t = 0.0
# Establish lists with initial position and velocity components and time.
x_list = [x]
y_list = [y]
z_list = [z]
vx_list = [vx]
vy_list = [vy]
vz_list = [vz]
t_list = [t]
# Set up visual elements.
mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)
plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)
ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)
ball.trail = visual.curve(color=ball.color)
while y >= 0.0:
visual.rate(100) # Limit to no more than 100 iterations per second.
t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)
x_list.append(x)
y_list.append(y)
z_list.append(z)
vx_list.append(vx)
vy_list.append(vy)
vz_list.append(vz)
t_list.append(t)
ball.pos = (x,y,z)
ball.trail.append(pos=ball.pos)
return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list
def add(i,j,time=tau): grid[i,j]=True s = sphere(radius=0.5) s.pos = i,j #i-50,j-50 color = 1 #time/tau#(1-1*exp(-t/tau)) s.color = color,color,color
def draw_crystal(r, attr, types): # draw atoms for i in range(len(r)): xyz,s = np.array(r[i]),np.array(attr[i]) #choose colour depending on spin direction (make the col vector the unit vector) if (s[0]==0 and s[1]==0 and s[2]==0): col = np.array((0,0,0)) else: col = s/np.sqrt(np.dot(s,s)) #and if any are less than zero, add the complementary if col[0] < 0: col[1]-= col[0] col[2] -=col[0] col[0] = 0 if col[1] < 0: col[0]-= col[1] col[2] -=col[1] col[1] = 0 if col[2] < 0: col[0]-= col[2] col[1] -=col[2] col[2] = 0 spingro = 0.2 #because mu_B is 10^-24, so we need to make it about ~10^-10 to display print xyz,s pointer = v.arrow(pos=xyz-s*spingro/2, axis=s*spingro, color=col) #draw spheres on the atom sites colour,size = atom_colours(types[i]) pointer = v.sphere(pos=xyz, color=colour, radius=0.1*size)
def _displayAtoms(self):
"""Display the position of atoms in the system.
Call this the first time to display the atoms on the visual.
Call it again to update all the positions. You don't need to
re-make the box at every step, it behaves smartly and just
moves the particles around.
"""
if visual is None:
return
vizColors = self.vizColors
vizRadius = self.vizRadius
atoms = self._atoms
S = self.S
# Now go add/update all atom positions, etc.
for i in range(self.S.N):
pos = S.atompos[i]
coords = S.coords(pos, raw=True)
type_ = S.atomtype[i]
radius = vizRadius.get(type_, self.radius)
color = vizColors.get(type_, visual.color.white)
# create the particle if not existing yet:
if len(atoms) <= i:
atoms.append(visual.sphere(pos=coords, radius=radius))
atoms[i].opacity = .2
# update it if it's already there (yes, it re-sets pos...)
atoms[i].visible = 1
atoms[i].pos = coords
if not hasattr(atoms[i], 's12viz'):
atoms[i].color = color
atoms[i].radius = radius
# hide all higher particle numbers:
for i in range(self.S.N, len(atoms)):
atoms[i].visible = 0
def __init__(self, pos=(-20, 0, 10), axis=(0, 5, 1), radius=.5, length=0):
"""
Construct it with a preset or given geometry.
"""
# calibration (see: calibrate(value))
self.zero = None
# a cylinders length MUST NEVER be '0' in pvisual ...
if length == 0:
length = 0.000001
# color and material
self.hot_color = (1, 0, 0)
### for now say: below zero this liquid is expanding...
self.cold_color = (0.4, 0.4, 1)
opacity = 1
material = materials.rough
# visualize the reservoir
self.reservoir = sphere(pos=pos, radius=radius*4, color=self.hot_color,\
opacity=opacity, material=material)
# visualize the expander
self.expander = cylinder(pos=pos, axis=axis, radius=radius,\
length=length, color=self.hot_color,\
opacity=opacity, material=material)
# add a label
p = self.calc_label_pos(pos)
self.label = label(pos=p, text=u'T: 0.0\xb0C')
def golf_ball_calc(x,y,z,vx,vy,vz,dt,m,g,B2,S0,w,w_vector):
t = 0.0
x_list = [x]
y_list = [y]
z_list = [z]
vx_list = [vx]
vy_list = [vy]
vz_list = [vz]
t_list = [t]
v_vector = visual.vector(vx,vy,vz)
tee = visual.box(pos=(0,0,0), length=0.05, width=0.05, height=0.5,color=visual.color.white)
ball = visual.sphere(pos=(x,y,z), radius = 0.25, color = visual.color.white)
ball.trail = visual.curve(color = visual.color.red)
while y > 0.0:
visual.rate(100)
t,x,y,z,vx,vy,vz = golfball_step(t,x,y,z,vx,vy,vz,m,g,B2,S0,w,dt,w_vector,v_vector)
x_list.append(x)
y_list.append(y)
z_list.append(z)
vx_list.append(vx)
vy_list.append(vy)
vz_list.append(vz)
t_list.append(t)
v_vector = visual.vector(vx,vy,vz)
ball.pos = (x,y,z)
ball.trail.append(pos=ball.pos)
return t_list,x_list,y_list,z_list,vx_list,vy_list,vz_list
def sResorte(self):
self.kR=self.kR.get()
self.masaR=self.masaR.get()
try:
self.kR=float(self.kR)
self.masaR=float(self.masaR)
except:
self.alerta()
gdpos=vgraph.gdisplay(x=600,y=0,xtitle='Tiempo',ytitle='Posicion')
plotpos=vgraph.gcurve(gdisplay=gdpos,color=vs.color.red)
gdvel=vgraph.gdisplay(x=600,y=600,xtitle='Velocidad',ytitle='Tiempo')
plotvel=vgraph.gcurve(gdisplay=gdvel,color=vs.color.blue)
gdacl=vgraph.gdisplay(x=0,y=900,xtitle='Aceleracion',ytitle='Tiempo')
plotacl=vgraph.gcurve(gdisplay=gdacl,color=vs.color.green)
resorte=vs.helix(pos=(0,5,0),axis=(0,0,-1),radius=0.5,color=vs.color.red)
resfera=vs.sphere(pos=(0,0,0),radius=0.7,color=vs.color.blue)
t=0
while t<=100:
resorte.axis=(0,-5+3*np.cos(np.sqrt(self.kR/self.masaR)*t),-1)
resfera.pos=(0,3*np.cos(np.sqrt(self.kR/self.masaR)*t),0)
plotpos.plot(pos=(t,3*np.cos(np.sqrt(self.kR/self.masaR)*t)))
plotvel.plot(pos=(t,-3*np.sqrt(self.kR/self.masaR)*np.sin(np.sqrt(self.kR/self.masaR)*t)))
plotacl.plot(pos=(t,-3*(self.kR/self.masaR)*np.cos(np.sqrt(self.kR/self.masaR)*t)))
t+=0.01
vs.rate(100)
def __init__(self, net):
self.sphereList = [] #list to hold the nodes (as vPython spheres)
self.rodList = [] #list to hold the edges (as vPython cylinders)
self.Net = net #NetworkCreation instance passed by reference
print 'Start visualising'
r = 1.0 #radius of circle that nodes are in
delta_theta = (2.0 * math.pi) / len(
self.Net.nodeList) #calculate angle between nodes
theta = 0 #start 'counter' theta at zero
for N in self.Net.nodeList:
sph = v.sphere(pos=v.vector(r * math.cos(theta),
r * math.sin(theta), 0),
radius=0.015,
color=v.color.green)
#for each node create a sphere in a position on the circumference of the circle
self.sphereList.append(sph) #add this sphere to the list
theta += delta_theta #increment the angle by the calculated delta_theta
for E in self.Net.edgeList: #for each edge...
pos1 = self.sphereList[E[
0]].pos #take positions of the corresponding nodes from the sphereList
pos2 = self.sphereList[E[1]].pos
rod = v.cylinder(pos=pos1,
axis=pos2 - pos1,
radius=0.0025,
color=v.color.white)
#create a vPython cylinder that stretches between the two nodes
self.rodList.append(rod) #add this cylinder to list
def __init__( self ): QtCore.QThread.__init__( self ) self.C = 0 # it is requred to process input events from visual window self.display = visual.display () self.s = visual.sphere( pos=visual.vector( 1, 0, 0 ) ) self.keep_running=True
def _displayDiff(self):
"""Display arrows for where particles have moved."""
if self.S0 is None: return
objs = self._atoms
S = self.S
S0 = self.S0
# Delete all objects:
for i in range(len(objs)):
objs[-1].visible = 0
del objs[-1]
for i in range(S.N):
startPos = S.atompos[i]
endPos = S0.atompos[i]
if startPos not in self._limit:
continue
if startPos == endPos:
objs.append(visual.sphere(pos=S.coords(startPos), radius=.15))
else:
startCoords = S.coords(startPos)
endCoords = S0.coords(endPos)
dist = math.sqrt(sum((endCoords-startCoords)**2))
if dist > S.L/2:
continue
objs.append(
visual.arrow(pos=startCoords, axis=endCoords-startCoords,
shaftwidth=.1, headlength=1, fixedwidth=1
))
def scalar_field(r,phi,phimin=0,phimax=0,colourtype='rainbow',scale=1): field = [] #work out limits of phi if not provided if(phimin==phimax==0): phimin = np.min(np.abs(phi)) phimax = np.max(np.abs(phi)) #if they're the same because all passed field values are identical if(phimin==phimax): phimin = 0 for i in range(len(r)): #colour from black to white at fmax val = (np.abs(phi[i]-phimin))/(phimax-phimin) if(colourtype=='rainbow'): colour = col_rainbow(val) opacity = 1.0 elif(colourtype=='bw'): colour = (val,val,val) opacity = 1.0 elif(colourtype=='rainbow_complex'): colour = col_rainbow_complex(val,np.angle(phi[i])) opacity = 1.0 elif(colourtype=='rainbow_complex_transparency'): colour = col_rainbow_theta(np.angle(phi[i])) opacity = val*0.95 + 0.05 #make it such that the minimum opacity is not zero field.append(v.sphere(pos=r[i], color=colour, radius=0.1*scale, opacity=opacity)) return field
def __init__(self, n=10):
"""Create n Boids and one carrot.
tracking: indicates whether the carrot follows the mouse
"""
self.boids = [Boid() for i in range(n)]
self.carrot = visual.sphere(pos=(1,0,0), radius=0.1, color=(1,0,0))
self.tracking = False
def __init__(self, ini=None):
wx.Frame.__init__(self, None)
self.Splitter = wx.SplitterWindow(self)
self.p1 = wx.Panel(self.Splitter)
self.p2 = wx.Panel(self.Splitter)
self.Splitter.SplitVertically(self.p1, self.p2)
self.Splitter.SetMinimumPaneSize(20)
Sizer = wx.BoxSizer()
Sizer.Add(self.Splitter, 1, wx.EXPAND)
self.SetSizer(Sizer)
# create a VPython application, just an copy of the Ball-demo
floor = visual.box(pos=(0, 0, 0),
length=4,
height=0.5,
width=4,
color=visual.color.blue)
ball = visual.sphere(pos=(0, 4, 0), radius=1, color=visual.color.red)
ball.velocity = visual.vector(0, -1, 0)
dt = 0.01
# initialize the State_Machine and start the timer
self.VP_State = 0
self.Old_Size = (0, 0)
self.Timer = wx.Timer(self)
# the third parameter is essential to allow other timers
self.Bind(wx.EVT_TIMER, self._On_Timer, self.Timer)
self.Timer.Start(100)
def PlotSphereEvolution3(f):
data = json.loads(open(f, "r").read())
center = (
(data["SystemSize"][1][0]+data["SystemSize"][0][0])*0.5,
(data["SystemSize"][1][1]+data["SystemSize"][0][1])*0.5,
(data["SystemSize"][1][2]+data["SystemSize"][0][2])*0.5
)
scene = vs.display(title='3D representation',
x=0, y=0, width=1920, height=1080,
center=center,background=(0,0,0)
)
vs.box(pos=center,
length=data["SystemSize"][1][0]-data["SystemSize"][0][0],
height=data["SystemSize"][1][1]-data["SystemSize"][0][1],
width= data["SystemSize"][1][2]-data["SystemSize"][0][2],
opacity=0.2,
color=vs.color.red)
spheres = [vs.sphere(radius=data["SphereSize"],pos=(data["Data"][0][0][i], data["Data"][1][0][i], data["Data"][2][0][i])) for i in range(data["SpheresNumber"])]
nt = 0
while True:
vs.rate(60)
for i in range(data["SpheresNumber"]):
spheres[i].pos = (data["Data"][0][nt][i], data["Data"][1][nt][i], data["Data"][2][nt][i])
if nt + 1 >= data["SavedSteps"]:
nt = 0
else:
nt += 1
def PlotSpheres3(f):
data = json.loads(open(f, "r").read())
scene = vs.display(title='3D representation',
x=0, y=0, width=1920, height=1080,
autocenter=True,background=(0,0,0))
vs.box(pos=(
(data["SystemSize"][1][0]+data["SystemSize"][0][0])*0.5,
(data["SystemSize"][1][1]+data["SystemSize"][0][1])*0.5,
(data["SystemSize"][1][2]+data["SystemSize"][0][2])*0.5
),
length=data["SystemSize"][1][0]-data["SystemSize"][0][0],
height=data["SystemSize"][1][1]-data["SystemSize"][0][1],
width= data["SystemSize"][1][2]-data["SystemSize"][0][2],
opacity=0.2,
color=vs.color.red)
spheres = [vs.sphere(radius=data["SphereSize"],pos=(data["Data"][0][i], data["Data"][1][i], data["Data"][2][i])) for i in range(data["SpheresNumber"])]
vs.arrow(pos=data["SystemSize"][0], axis=(1,0,0), shaftwidth=0.1, color=vs.color.red)
vs.arrow(pos=data["SystemSize"][0], axis=(0,1,0), shaftwidth=0.1, color=vs.color.green)
vs.arrow(pos=data["SystemSize"][0], axis=(0,0,1), shaftwidth=0.1, color=vs.color.blue)
while True:
vs.rate(60)
def __init__(self):
self.NodeList = []
self.EdgeList = []
r = 1.0
delta_theta = (2.0 * math.pi) / len(Net.Nodes)
theta = 0
for N in Net.Nodes:
node = [
N.ID,
v.sphere(pos=v.vector(r * math.cos(theta), r * math.sin(theta),
0),
radius=0.01,
color=v.color.white)
]
theta += delta_theta
self.NodeList.append(node)
self.NodeList = dict(self.NodeList)
for ind in Net.ChansIndex:
pos1 = self.NodeList[Net.ChansIndex[ind][0]].pos
pos2 = self.NodeList[Net.ChansIndex[ind][1]].pos
ID = ind
rod = v.cylinder(pos=pos1,
axis=(pos2 - pos1),
radius=0.0025,
color=v.color.green)
edge = [ind, rod]
self.EdgeList.append(edge)
self.EdgeList = dict(self.EdgeList)
def __init__(self, pos, moment, scene=None):
self.pos = pos
self.moment = moment
if scene:
Shape.__init__(self, scene)
self.obj = sphere(pos=pos, radius=0.5, display=scene)
def _handle_dfs(self, bone, parent, frame, transform_stack):
# Calculate new direction and position
direction = (bone.xyz_data[frame, :] -
parent.xyz_data[frame, :]).tolist()
pos = parent.xyz_data[frame, :].tolist()
# FIXME: Seems inefficient.
xdir = np.asarray(transform_stack[-1][0, :]).tolist()[0]
ydir = np.asarray(transform_stack[-1][1, :]).tolist()[0]
zdir = np.asarray(transform_stack[-1][2, :]).tolist()[0]
if bone.name in self.bone_data:
# Retrieve and update objects
cyl, s, ax = self.bone_data[bone.name]
cyl.pos = pos
cyl.axis = direction
s.pos = bone.xyz_data[frame, :].tolist()
ax.update(xdir, ydir, zdir, pos)
else:
# Create and save objects.
cyl = visual.cylinder(pos=pos,
axis=direction,
radius=Pose.cyl_radius)
s = visual.sphere(pos=bone.xyz_data[frame, :].tolist(),
radius=Pose.sphere_radius)
axes = Axes(xdir, ydir, zdir, 0.3, pos=pos, width=0.01)
self.bone_data[bone.name] = (cyl, s, axes)
def sand(self):
self.top = cone(pos=(0, self.time * 1.1, 0), axis=(0, -1, 0), color=(1, 1, 0))
self.bottom = cone(pos=(0, -self.time * 1.1, 0), axis=(0, 1, 0), color=(0.5, 0.5, 0))
self.falling = cylinder(
pos=(0, self.time * 0.125, 0), axis=(0, -1, 0), color=(0.5, 0.5, 0), radius=self.time * 0.035
)
self.countdown = sphere(pos=(0, self.time * 1.5, 0), radius=0)
def add(i, j, time=tau):
grid[i, j] = True
s = sphere(radius=0.5)
s.pos = i, j #i-50,j-50
color = 1 #time/tau#(1-1*exp(-t/tau))
s.color = color, color, color
def Ch3_Uses():
print '-------------------- 3.1 Graphs ---------------------------\n'
#simple plot
plt.figure(facecolor="white")
x = [0.5, 1.0, 2.0, 4.0, 7.0, 10.0]
y = [1.0, 2.4, 1.7, 0.3, 0.6, 1.8]
plt.plot (x,y,'ro-')
plt.show()
#two plots with legends and different colors
plt.figure(facecolor="white")
x = linspace(0,12.56,100) #linspace takes three arguments initial and final value and the number of divisions
y = sin(x)
z = cos(x)
plt.plot(x,y,'g-',label = 'sin x')
plt.plot(x,z,'ro',label = 'cos x')
#colors allowed by python are r,g,b,c,m,y,k,w for red, green,blue,cyan,magenta,yellow,black,white
#Styles are -,o,--,s,* for solid line, dots, dash line, squares, stars,
plt.ylim(-1.1,1.1)
plt.xlim(-0.5,13)
plt.xlabel('from 0 to 4pi')
plt.ylabel('Trigonometric functions')
plt.title('la verdad')
leg = plt.legend()
plt.show()
plt.figure(facecolor="white")
data = loadtxt("alltxt/ch3-1.txt",float)
x = data[:,0]
y = data[:,1]
plt.plot(x,y)
plt.show()
print '------------------- 3.2 Scatter --------------------------\n'
print '------------------- 3.3 Density --------------------------\n'
plt.figure(facecolor="white")
data = loadtxt("cpresources/circular.txt",float)
plt.imshow(data,origin='lower')
#plt imshow()
plt.colorbar()
plt.show()
print '------------------- 3.4 3D Graphics --------------------------\n'
sphere()
sphere(radius=0.5, pos=[1.0,-0.2,0.0])
sphere(color = color.green)
s = empty(10,sphere)
for n in range(10):
s[n]= sphere()
d = display(background = color.blue)
display(autoscale=False)#set the automatic zoom off
print '------------------- 3.5 Animations --------------------------\n'
s = sphere(pos=[0,0,0])
s.pos = [1,4,3]
return 'done'
def __init__(self, radius, **kwargs):
self.container = visual.frame(**kwargs)
self.ledsphere = visual.sphere(
frame=self.container, pos=(0, 0, 0),
radius=radius, color=visual.color.white,
material=visual.materials.emissive
)
self.ledlight = visual.local_light(frame=self.container, pos=(0, 0, 0), color=visual.color.white)