def create_grid(size, height):
has_height = (height != None and len(height) != 0)
row_step = (GRID_SIZE - (-GRID_SIZE)) / float(size - 1)
col_step = (GRID_SIZE - (-GRID_SIZE)) / float(size - 1)
# first calculate all points
points = [(GRID_SIZE - col * col_step, has_height and height[row][col] or 0, GRID_SIZE - row * row_step) for
row in xrange(size) for col in xrange(size)]
horizontal_curves = []
vertical_curves = []
# horizontal lines
for i in xrange(0, len(points), size):
for j in xrange(size - 1):
horizontal_curves.append(curve(frame=grid_frame, pos=[
points[i + j],
points[i + j + 1]
]))
# vertical lines
for i in xrange(0, size):
#print "i=%d" % i
for j in xrange(0, len(points) - size, size):
#print "j=%d" % j
#print "i+j=%d" % (i+j)
#print "i+j+size=%d" % (i+j+size)
if i + j < len(points) and i + j + size < len(points):
vertical_curves.append(curve(frame=grid_frame, pos=[
points[i + j],
points[i + j + size]
]))
return (horizontal_curves, vertical_curves)
def drawEdge(self, index, coeff, frame):
coords = [[], []]
for i in range(2):
for j in range(2):
coords[i].append(self.ends[i].coords[j])
coords[i].append(self.ends[i].coords[2] + index * coeff)
curve(pos=coords, color=color.black, radius=coeff, frame=frame)
def showAxes( self, frame, color, length, pos ): # Use frame=None for world.
directions = [ vs.vector(length, 0, 0), vs.vector(0, length, 0), vs.vector(0, 0, length) ]
texts = ["x","y","z"]
pos = vs.vector(pos)
for i in range(3): # each direction
vs.curve( frame=frame, color=color, pos=[pos, pos+directions[i]])
vs.label( frame=frame, color=color, pos=pos+directions[i], text=texts[i], opacity=0, box=False )
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 iterate(tree, gen, filled, spec_fill=0):
"""Itère sur l'arbre (on commence = gen=1 et filled=[0, 0])
filled détermine la hauteur maximale
où on peut dessiner pour une génération donnée
gen est la génération"""
# On stockera dans height les différentes hauteurs des sous-arbres
height = []
width = gen * COLWIDTH
altitude = 0
current_path = None
x = width - COLWIDTH / 2
if len(filled) <= gen:
filled.append(filled[-1])
for k in xrange(len(tree[INDEX_SUBS])):
if k == 0:
h, w, alt, new_path = iterate(
tree[INDEX_SUBS][k],
gen + 1,
filled,
max(filled[gen], spec_fill) - (len(tree[INDEX_SUBS]) - 1) / 2 * COLWIDTH,
)
else:
h, w, alt, new_path = iterate(tree[INDEX_SUBS][k], gen + 1, filled)
if w > width:
width = w
if alt > altitude:
altitude = alt
height.append(h)
if new_path != None:
current_path = new_path
if len(height) == 0:
height.append(max(filled[gen], filled[gen - 1], spec_fill) + COLWIDTH / 2)
center = (height[0] + height[-1]) / 2
altitude = max(altitude, center + COLWIDTH / 2)
# Les traits
for k in xrange(len(tree[INDEX_SUBS])):
visual.curve(pos=[(center, -x, 0), (height[k], -x - COLWIDTH, 0)], radius=LINEWIDTH)
# Le nœud
point = (center, -x, 0)
if tree[INDEX_STATE] == 2:
current_path = tree[INDEX_PATH]
# Le nœud courant est vert
visual.sphere(pos=point, radius=WIDTH, color=(0.0, 1.0, 0.0))
elif tree[INDEX_STATE] == 1:
# Si c'est lu, on met en rouge
visual.sphere(pos=point, radius=WIDTH, color=(0.5, 0.0, 0.0))
else:
# Sinon, on met en rouge clair
visual.sphere(pos=point, radius=WIDTH, color=(1.0, 0.3, 0.3))
self.dots[tree[INDEX_PATH]] = point
if filled[gen] < height[-1] + COLWIDTH / 2:
filled[gen] = height[-1] + COLWIDTH / 2
return center, width, altitude, current_path
def draw_grid(self, width, length):
scene.center = (int(width / 2), int(length / 2))
scene.forward = (0, 0, -1) # Default view direction
for x in range(-5, width * 10 + 5, 10):
curve(pos=[(x / 10 + 0.5, -0.5), (x / 10 + 0.5, length - 0.5)],
color=color.green)
for y in range(-5, length * 10 + 5, 10):
curve(pos=[(-0.5, y / 10 + 0.5), (width - 0.5, y / 10 + 0.5)],
color=color.green)
def drawGrid( posn=(0,0,0), sq=1, H=12, W = 1, normal='z', colour= clr.white ) :
ht = H*sq
wd = W*sq
for i in range( 0, ht+1, sq ): # FOR EACH HORIZONTAL LINE
if normal == 'x':
vs.curve( pos=[(posn[1]+i, posn[0], posn[2]+wd),(posn[1]+i, posn[0], posn[2])], color=colour)
#print (posn[0] + posn[1]+i + posn[2]+wd) #for testing purposes
else: vs.curve( pos=[(posn[0], posn[1], posn[2]+i),
(posn[0]+wd, posn[1], posn[2]+i)], color=colour)
def axes( frame, colour, sz, posn ): # Make axes visible (of world or frame).
# Use None for world.
directions = [vs.vector(sz,0,0), vs.vector(0,sz,0), vs.vector(0,0,sz)]
texts = ["X","Y","Z"]
posn = vs.vector(posn)
for i in range (3): # EACH DIRECTION
vs.curve( frame = frame, color = colour, pos= [ posn, posn+directions[i]])
vs.label( frame = frame,color = colour, text = texts[i], pos = posn+ directions[i],
opacity = 0, box = False )
def __init__(self, size=100, small_interval=5, big_interval=50):
self.frame = visual.frame(pos=(0,0,0))
for i in range(-size, size+small_interval, small_interval):
if i % big_interval == 0:
c = visual.color.gray(0.65)
else:
c = visual.color.gray(0.25)
visual.curve(frame=self.frame, pos=[(i,0,size),(i,0,-size)], color=c)
visual.curve(frame=self.frame, pos=[(size,0,i),(-size,0,i)], color=c)
def plate(self):
if (self.container):
for obj in self.container.objects:
obj.visible = 0
self.container = visual.frame()
field_length = self.length() + 2*self.config['display']['radius']
field_width = 3*self.config['display']['radius']*self.count + 10
if (self.ordered):
init = self.conns[0].obj[self.orderby]
pborder = 0
t = -1
i = 0
for conn in self.conns:
if (init != conn.obj[self.orderby]):
if ((i % 2) == 1):
bcolor = self.config['colors']['box_light']
else:
bcolor = self.config['colors']['box']
if type(init) == (type(1)):
labeltext = self.orderby + "\n%d" % (init)
elif type(init) == (type('str')):
labeltext = self.orderby + "\n'%s'" % (init)
visual.box(frame=self.container, pos=(field_length/2 - self.level, -(self.config['display']['radius']+1), 3*self.config['display']['radius']*t/2+self.config['display']['radius'] + pborder/2), \
width = (3*self.config['display']['radius']*t - pborder), length = field_length, height = 1, color = bcolor)
visual.label(frame=self.container, pos = (self.config['display']['radius'] -self.level, 0, 3*self.config['display']['radius']*t/2+self.config['display']['radius'] + pborder/2),\
yoffset = 4*self.config['display']['radius'], xoffset = -4* self.config['display']['radius'],text = labeltext)
pborder = 3*self.config['display']['radius']*t+self.config['display']['radius']
init = conn.obj[self.orderby]
i += 1
t += 1
if type(init) == (type(1)):
labeltext = self.orderby + "\n%d" % (init)
elif type(init) == (type('str')):
labeltext = self.orderby + "\n'%s'" % (init)
if ((i % 2) == 1):
bcolor = self.config['colors']['box_light']
else:
bcolor = self.config['colors']['box']
visual.box(frame=self.container, pos=(field_length/2 - self.level, -(self.config['display']['radius']+1), 3*self.config['display']['radius']*t/2+self.config['display']['radius'] + pborder/2), \
width = (3*self.config['display']['radius']*t - pborder), length = field_length, height = 1, color = bcolor)
visual.label(frame=self.container, pos = (self.config['display']['radius'] - self.level, 0, 3*self.config['display']['radius']*t/2+self.config['display']['radius'] + pborder/2),\
yoffset = 4*self.config['display']['radius'], xoffset = -4* self.config['display']['radius'], text = labeltext)
else:
visual.box(frame=self.container, pos = (field_length/2 - self.level, -(self.config['display']['radius']+1),field_width/2), width = field_width, length = field_length, height = 1, color = self.config['colors']['box'])
desctext = 'From %s to %s\n' % (time.strftime("%F %H:%M:%S", time.localtime(self.starttime)), \
time.strftime("%F %H:%M:%S", time.localtime(self.endtime)))
desctext += self.build_str_filter(" and ", "Filtering on ")
visual.label(frame=self.container, pos = (field_length/2 - self.level, self.config['display']['radius']+0.5,0), yoffset = 4*self.config['display']['radius'], text = desctext)
for i in range(self.config['display']['graduation']):
visual.curve(frame=self.container, pos=[(field_length/self.config['display']['graduation']*i - self.level, -(self.config['display']['radius']+1)+1,0), (field_length/self.config['display']['graduation']*i - self.level,-(self.config['display']['radius']+1)+1,field_width)])
for i in range(self.config['display']['graduation']/self.config['display']['tick']+1):
ctime = time.strftime("%H:%M:%S", time.localtime(self.mintime + field_length/self.config['display']['graduation']*self.config['display']['tick']*i))
visual.label(frame=self.container, pos=(field_length/self.config['display']['graduation']*self.config['display']['tick']*i - self.level, -(self.config['display']['radius']+1)+1,0), text = '%s' % (ctime), border = 5, yoffset = 1.5*self.config['display']['radius'])
def __init__(self, npts=100000, Rotate=False, title=''):
ptsize = 3
mapptsize = 1
self.scene_angle = 0
self.localscene = visual.display(title=title + ' Local Coordinate System')
self.globalscene = visual.display(title=title + ' Global Coordinate System')
#self.globalscene.background = (1, 1, 1)
#self.globalscene.up = (0, 0, 1)
#self.globalscene.forward = (0, 1, -0.4)
self.currentrow = 0
self.auto_colour = False
# Set up the global coordinate frame visualiser
self.globalscene.select()
self.globalscene.up =(0, 0, 1.0)
#self.visualrobot = visual.box(length=3, height=2, width=1.5)
w = 1
wid = 0.2
self.robotpts = np.array(( (0, -wid, 0, w), (0, wid, 0, w), (3*wid, 0, 0, w), (0, -wid, 0, w) ))
#self.visualrobot = visual.points(pos=self.robotpts[:, :3], size=4, shape='round', color=(0, 1, 1))
self.visualrobot = visual.curve(pos=self.robotpts[:, :3], color=(0, 1, 1))
X = np.array([(-1, -1), (-1, 1), (1, 1), (1, -1), (-1, -1)])
square = visual.curve(pos=50*X)
self.leftmappts = visual.points(size=ptsize, shape='square', color=(1, 0, 0))
self.rightmappts = visual.points(size=ptsize, shape='square', color=(0, 1, 0))
self.spinmappts = visual.points(size=ptsize, shape='square', color=(0, 0, 1))
X = np.zeros((npts, 3))
self.mappts = visual.points(pos=X, size=mapptsize, shape='square', color=(1, 1, 1))
self.trajpts_ind = 0
self.trajpts = visual.points(pos=np.zeros((10000, 3)), color=(0, 0, 1), size=2)
visual.scene.show_rendertime = True
if Rotate:
# Enable continuous rotation
RV = RotateVisual(self.globalscene)
RV.start()
else:
# Enable mouse panning
MT = dispxyz.EnableMouseThread(self.globalscene)
MT.start()
# Set up the local coordinate frame visualiser
if showlocal:
self.localscene.select()
self.leftpts = visual.points(color=(1, 0, 0), size=ptsize, shape='square')
self.rightpts = visual.points(color=(0, 1, 0), size=ptsize, shape='square')
self.spinpts = visual.points(color=(0, 0, 1), size=ptsize, shape='square')
visual.scene.show_rendertime = True
self.colourmin = -4
self.colourmax = 4
def getxmas():
"""Creates a complete Christmas Tree dipole assembly (minus base) at (0,0,0)
Returned value is a tuple of (xmas, olist), where xmas is the frame containing the
complete Christmas Tree dipoles, and olist is a list of all of the component objects."""
xmas = visual.frame()
olist = []
for direction in ['E', 'W', 'N', 'S']: # Create the four dipole arms
ef, elist = getelement(frame=xmas, which=direction)
olist.append(ef)
olist.append(elist)
# These objects (s1-s3) are the white plastic space assembly
s1 = visual.curve(pos=[
V(-0.233, -0.233, 0.59),
V(0.233, -0.233, 0.59),
V(0.233, 0.233, 0.59),
V(-0.233, 0.233, 0.59),
V(-0.233, -0.233, 0.59)
],
frame=xmas,
radius=0.02,
material=SPACERMAT,
color=color.white)
s2 = visual.curve(pos=[V(-0.233, 0, 0.59),
V(0.233, 0, 0.59)],
frame=xmas,
radius=0.02,
material=SPACERMAT,
color=color.white)
s3 = visual.curve(pos=[V(0, -0.233, 0.59),
V(0, 0.233, 0.59)],
frame=xmas,
radius=0.02,
material=SPACERMAT,
color=color.white)
# This is an approximation to the LNA and feedhorn at the top of the tree
lna = visual.box(pos=V(0, 0, 1.63),
frame=xmas,
height=0.03,
length=0.03,
width=0.08,
material=SPACERMAT,
color=color.white)
# This is the cable duct going vertically down the centre of the tree from the LNA
pole = visual.curve(pos=[V(0, 0, 0.38), V(0, 0, 1.73)],
frame=xmas,
radius=POLER,
material=POLEMAT,
color=color.white)
olist.append([s1, s2, s3, lna, pole])
return xmas, olist
def axes(frame, colour, size, posn):
"""Make axes visible (of world or frame)."""
# Use None for world.
directions = [
vs.vector(size, 0, 0), vs.vector(0, size, 0), vs.vector(0, 0, size)]
texts = ["X", "Y", "Z"]
posn = vs.vector(posn)
for i in range(3): # EACH DIRECTION
vs.curve(frame=frame, color=colour, pos=[posn, posn+directions[i]])
vs.label(frame=frame, color=colour, text=texts[i],
pos=posn + directions[i], opacity=0, box=False)
def set_scene(R): # draw scene, ball, trails, spin, info box
scene = vp.display(background=(.2,.5,1), forward=(-1,-.1,-.1),
center=(.5*R,1,0), ambient=.4, fullscreen=1)
floor = vp.box(pos=(R/2,0,0), length=1.1*R, height=.1, width=8,
color=vp.color.orange, opacity=0.7) # transparent
zone = vp.curve(pos=[(R,0,1),(R,1,1),(R,1,-1),(R,0,-1)], radius=.02)
ball = vp.sphere(pos=(0,0,0), radius=.2, material=vp.materials.rough)
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 display(self,data):
#dominant = reduce(lambda y,x: x if x[1] > y[1] else y, zip(range(len(data)), data), [0,0])
#if (dominant[1] > 10 and dominant[0] != 0.0):
# freq = freqs[dominant[0]]
# print freq,
# note = ftomidi(freq)
# print note
# PlayNote(note)
# dominant = dominant[0]
#else:
# dominant = False
if (len(self.curves) > self.maxlen):
todel = self.curves.pop()
todel.visible = False
del todel
for oldcurve in self.curves:
for point in range(len(oldcurve.pos)):
oldcurve.pos[point][2] -= self.step
y = []
for point in data:
y.append(point)
y.append(point)
curve = visual.curve(color=visual.color.white, display=self.g, radius=0)
for point in zip(range(len(data)),data):
r = g = b = 1
curve.append(pos=(point[0],point[1] * 10,0), color=(r,g,b))
self.curves.insert(0,curve)
def display(self, data):
#dominant = reduce(lambda y,x: x if x[1] > y[1] else y, zip(range(len(data)), data), [0,0])
#if (dominant[1] > 10 and dominant[0] != 0.0):
# freq = freqs[dominant[0]]
# print freq,
# note = ftomidi(freq)
# print note
# PlayNote(note)
# dominant = dominant[0]
#else:
# dominant = False
if (len(self.curves) > self.maxlen):
todel = self.curves.pop()
todel.visible = False
del todel
for oldcurve in self.curves:
for point in range(len(oldcurve.pos)):
oldcurve.pos[point][2] -= self.step
y = []
for point in data:
y.append(point)
y.append(point)
curve = visual.curve(color=visual.color.white,
display=self.g,
radius=0)
for point in zip(range(len(data)), data):
r = g = b = 1
curve.append(pos=(point[0], point[1] * 10, 0), color=(r, g, b))
self.curves.insert(0, curve)
def frame(self, sign):
self.glass = curve(
pos=[
(sign * self.time, -self.time * 1.1, 0),
(sign * self.time * 0.05, -self.time * 0.1, 0),
(sign * self.time * 0.05, self.time * 0.1, 0),
(sign * self.time, self.time * 1.1, 0),
(sign * self.time, self.time * 1.15, 0),
],
radius=self.time * 0.025,
)
self.base = cylinder(
pos=(0, sign * self.time * 1.15, 0),
axis=(0, 1, 0),
length=self.time * 0.1,
radius=self.time * 1.2,
color=(0.66, 0.46, 0.13),
)
self.pole = cylinder(
pos=(sign * self.time, -self.time * 1.1, 0),
axis=(0, 1, 0),
length=self.time * 2.3,
radius=self.time * 0.06,
color=(0.66, 0.46, 0.13),
)
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 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 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 extractXCurve(point):
"""after forwardMap has been called, call this
on the x parameter to get a visual curve of the elastica"""
vcurve = vis.curve()
for part in point.x:
vcurve.append([part[0], part[1]])
return vcurve
def gettreecable(treepos=V(0, 0, 0)):
"""Returns a single arc of cable from vertical (exiting duct at centre of dipole) to
horizontal (short distance from base, shading to the ground color).
The cable is positioned for a Christmas Tree positioned at 'treepos', and the
cable points towards the APIU at (0,0,0).
Returned is a tuple (cable, olist) where cable is the frame containing the
curve (we need a frame for a single curve object, because curve objects can't
be rotated), and a list containing the single component object.
"""
cframe = visual.frame()
cstartpos = treepos + (0, 0, 0.4
) # Where the cable leaves the xmas tree trunk
theta = visual.atan2(treepos.y, treepos.x) # Angle to the APIU at (0,0,0)
carc = visual.paths.arc(radius=0.37,
angle1=-visual.pi / 2,
angle2=0,
up=(0, -1, 0))
carc.pos = [p + treepos + V(0.37, 0, 0.4) for p in carc.pos[::-1]]
c1 = visual.curve(frame=cframe,
pos=carc,
radius=0.0129 / 2,
color=color.blue)
c1.append(pos=treepos + V(1.5, 0, -0.065), color=GCOLOR)
cframe.rotate(angle=theta + visual.pi, axis=(0, 0, 1), origin=cstartpos)
return cframe, [c1]
def __init__(self, num_objs, ids):
threading.Thread.__init__(self)
visual.scene.autoscale = False
visual.scene.center = (2 * 5 - 1.5, -3, 0)
vt.scene.title = "Motion Visualizer"
f = visual.frame()
self.text = []
self.objs = []
self.graphs = []
self.data = []
self.index = []
self.stop = False
for i in range(num_objs):
self.text.append(None)
self.objs.append(VisObj((i * 5, 1, 0), f))
self.data.append([])
self.index.append(0)
self.graphs.append([])
self.data[-1] = [[], [], []]
for n in range(100):
self.data[-1][0].append([(i * 5 - 1.5) + (3.0 / 100) * n, -5,
0])
for n in range(100):
self.data[-1][1].append([(i * 5 - 1.5) + (3.0 / 100) * n, -4,
0])
for n in range(100):
self.data[-1][2].append([(i * 5 - 1.5) + (3.0 / 100) * n, -3,
0])
self.graphs[-1].append(
visual.curve(pos=self.data[-1][0],
radius=0.05,
color=visual.color.red))
self.graphs[-1].append(
visual.curve(pos=self.data[-1][1],
radius=0.05,
color=visual.color.blue))
self.graphs[-1].append(
visual.curve(pos=self.data[-1][2],
radius=0.05,
color=visual.color.yellow))
def drawRay(self):
#print "Drawing Ray"
#print self.points
self.ray = curve(pos=self.points,
color=(0,0,0),
#radius=0.005
radius=0.002
)
def __init__(self, **kwargs):
super(Board, self).__init__(**kwargs)
visual.box(pos = (9, 9, -1),
size = (20, 20, 1),
color = (1, 0.75, 0),
material = visual.materials.wood,
frame = self)
# lines
params = dict(color = (.5, .5, .5), frame = self)
for i in range(19):
visual.curve(pos = [(0, i, 0), (18, i, 0)], radius = .05, **params)
for i in range(19):
visual.curve(pos=[(i, 0, 0), (i, 18, 0)], radius = .05, **params)
self.stones, self.star = [], []
for x in itertools.product((4, 10, 16), (4, 10, 16)): self.star.append(x[:])
def draw_route(self, route_points_list, color=vs.color.white):
if self.route is not None:
self.route.visible = False
del self.route
self.route = vs.curve(display=self.route_window,
pos=route_points_list,
color=color)
return
def __init__(self, **kwargs):
super(Board, self).__init__(**kwargs)
visual.box(pos=(9, 9, -1),
size=(20, 20, 1),
color=(1, 0.75, 0),
material=visual.materials.wood,
frame=self)
# lines
params = dict(color=(.5, .5, .5), frame=self)
for i in range(19):
visual.curve(pos=[(0, i, 0), (18, i, 0)], radius=.05, **params)
for i in range(19):
visual.curve(pos=[(i, 0, 0), (i, 18, 0)], radius=.05, **params)
self.stones, self.star = [], []
for x in itertools.product((4, 10, 16), (4, 10, 16)):
self.star.append(x[:])
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 getbundle(
spos=None,
bframe=None): # spos is position that cable centre exits the box
"""Returns a single bundle of 64 dipole cables as they exit the APIU. The parameter 'spos'
is the point at which they exit the SPIU box.
If the 'bframe' parameter is given, all objects are created inside this frame.
Note that the cable bundle returned always faces East - it most be rotated around
'spos' after it's created for bundles exiting the West side of the APIU.
Returned is a tuple of (cframe, blist) where cframe is the frame containing the cable
bundle, and blist is the list of component objects."""
cframe = visual.frame(frame=bframe)
startz = spos.z # Height above ground that cable centre exits the APIU box
# Arc from the entry point (horizontal) to halfway to the ground (vertical)
carc1 = visual.paths.arc(radius=startz / 2,
angle1=visual.pi,
angle2=visual.pi / 2,
up=(0, -1, 0))
carc1.pos = [p + spos + V(0, 0, -startz / 2) for p in carc1.pos]
c1 = visual.curve(frame=cframe,
pos=carc1,
radius=0.08 / 2,
color=color.blue)
# Arc from halfway to the ground (vertical) to the ground (horizontal)
carc2 = visual.paths.arc(radius=startz / 2,
angle1=visual.pi,
angle2=visual.pi / 2,
up=(0, 1, 0))
carc2.pos = [p + spos + V(startz, 0, -startz / 2) for p in carc2.pos]
c2 = visual.curve(frame=cframe,
pos=carc2,
radius=0.08 / 2,
color=color.blue)
# Append a point to the curve 1.5m out in the desert, fading from blue to the ground color
c2.append(pos=spos + V(1.5, 0, -startz), color=GCOLOR)
blist = [c1, c2]
return cframe, blist
def update_grid():
delete_current_grid()
if not showSpan:
return
global span_frame
span_frame = visual.frame()
vecs = map(lambda i: visual.vector(vectors[i].axis)*span_fact,selected)
for v in vecs:
rest = vecs[0:len(vecs)] # deep copy
rest.remove(v)
all_sums = all_sums_comb(rest)
for aSum in all_sums:
visual.curve(frame = span_frame, pos = [aSum,aSum+v], color = span_color)
if not is_span_positive:
visual.curve(frame = span_frame, pos = [aSum,aSum-v], color = span_color)
def drawGrid(self,
posn=(0, 0, 0),
sq=1,
H=12,
W=1,
normal='z',
colour=clr.white):
ht = H * sq
wd = W * sq
for i in range(0, ht + 1, sq): # FOR EACH HORIZONTAL LINE
if normal == 'x':
vs.curve(pos=[(posn[1] + i, posn[0], posn[2] + wd),
(posn[1] + i, posn[0], posn[2])],
color=colour)
#print (posn[0] + posn[1]+i + posn[2]+wd) #for testing purposes
else:
vs.curve(pos=[(posn[0], posn[1], posn[2] + i),
(posn[0] + wd, posn[1], posn[2] + i)],
color=colour)
def __init__(self, points, color, manifold):
self.__points = points
super(self.__class__, self).__init__(
visual.curve(
radius=0.01,
pos=[manifold.getCurrentPosVec(pos) for pos in points],
color=color,
display=manifold.display,
)
)
self.__manifold = manifold
def set_scene(R): # draw scene, ball, trails, spin, info box
scene = vp.display(background=(.2, .5, 1),
forward=(-1, -.1, -.1),
center=(.5 * R, 1, 0),
ambient=.4,
fullscreen=1)
floor = vp.box(pos=(R / 2, 0, 0),
length=1.1 * R,
height=.1,
width=8,
color=vp.color.orange,
opacity=0.7) # transparent
zone = vp.curve(pos=[(R, 0, 1), (R, 1, 1), (R, 1, -1), (R, 0, -1)],
radius=.02)
ball = vp.sphere(pos=(0, 0, 0), radius=.2, material=vp.materials.rough)
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 display(cylinders,Lx,Ly):
scene = visual.display(center = [Ly/2.0,.14,Lx/2.0], forward = [0,-1,0],
up = [1,0,0],background=(1,1,1))
surr = visual.curve(pos=[(0,0,0),(0,0,Lx),(Ly,0,Lx),(Ly,0,0),(0,0,0)],
radius=.005*Lx,color=(0,0,0))
for cyl in cylinders:
x = cyl.pos[0]
y = cyl.pos[1]
z = 0
rod = visual.cylinder(pos=(y,z,x), axis=(0,.001,0), radius = cyl.radius,
color=(200,0,0))
def animate_motion(x, k):
# Animate using Visual-Python
CO = zeros((n, 3))
B2 = zeros((n, 3))
C1 = zeros((n, 3))
C3 = zeros((n, 3))
CN = zeros((n, 3))
for i, state in enumerate(x[:,:5]):
CO[i], B2[i], C1[i], C3[i] = rd.anim(state, r)
# Make the out of plane axis shorter since this is what control the height
# of the cone
B2[i] *= 0.001
C1[i] *= r
C3[i] *= r
CN[i, 0] = state[3]
CN[i, 1] = state[4]
from visual import display, rate, arrow, curve, cone, box
black = (0,0,0)
red = (1, 0, 0)
green = (0, 1, 0)
blue = (0, 0, 1)
white = (1, 1, 1)
NO = (0,0,0)
scene = display(title='Rolling disc @ %0.2f realtime'%k, width=800,
height=800, up=(0,0,-1), uniform=1, background=white, forward=(1,0,0))
# Inertial reference frame arrows
N = [arrow(pos=NO,axis=(.001,0,0),color=red),
arrow(pos=NO,axis=(0,.001,0),color=green),
arrow(pos=NO,axis=(0,0,.001),color=blue)]
# Two cones are used to look like a thin disc
body1 = cone(pos=CO[0], axis=B2[0], radius=r, color=blue)
body2 = cone(pos=CO[0], axis=-B2[0], radius=r, color=blue)
# Body fixed coordinates in plane of disc, can't really be seen through cones
c1 = arrow(pos=CO[0],axis=C1[0],length=r,color=red)
c3 = arrow(pos=CO[0],axis=C3[0],length=r,color=green)
trail = curve()
trail.append(pos=CN[0], color=black)
i = 1
while i<n:
rate(k/ts)
body1.pos = CO[i]
body1.axis = B2[i]
body2.pos = CO[i]
body2.axis = -B2[i]
c1.pos = body1.pos
c3.pos = body1.pos
c1.axis = C1[i]
c3.axis = C3[i]
c1.up = C3[i]
c3.up = C1[i]
trail.append(pos=CN[i])
i += 1
def __init__(self, start=CGAL.Point_2(), end=CGAL.Point_2(), label=None, display=DEFAULT_SCENE): super(VSegment_2, self).__init__(start, end) self.__repr = None self.__line = visual.curve(pos=[(start.x(), start.y()), (end.x(), end.y())]) #self.color = visual.color.white #if label is not None: # self.label = label #else: # self.__label = DEF_SEGMENT_LABEL display.insertVSegments_2(self)
def input(self, data):
fft = data['fft']
if (len(self.curves) > self.maxlen):
todel = self.curves.pop()
todel.visible = False
del todel
for oldcurve in self.curves:
for point in range(len(oldcurve.pos)):
oldcurve.pos[point][2] -= self.step
y = []
for point in fft:
y.append(point)
y.append(point)
curve = visual.curve(color=visual.color.white,
display=self.g,
radius=0)
if data.has_key('dominantbucket'):
dominant = data['dominantbucket']
else:
dominant = False
if (self.lastdominant != dominant and self.label):
self.label.visible = False
del self.label
self.label = False
for point in zip(range(len(fft)), fft):
if dominant and (point[0] + 2) > dominant and (point[0] -
2) < dominant:
r = 1
g = 0
b = 0
if (self.lastdominant != dominant and dominant == point[0]):
self.label = visual.label(pos=(point[0], 10, 0),
text=str(data['note']),
xoffset=20,
yoffset=12,
height=10,
border=6,
font='sans')
else:
r = g = b = point[1] / 3
curve.append(pos=(point[0], point[1], 0), color=(r, g, b))
self.lastdominant = dominant
self.curves.insert(0, curve)
def draw(self):
import visual
frame = visual.frame()
outline = visual.curve(frame=frame,
pos=[(0.0,0.0,0.0),(1.0,0.0,0.0),
(1.0,1.0,0.0),(0.0,1.0,0.0),
(0.0,0.0,0.0)],color=visual.color.red)
for e in self.elements:
outline = []
for n in e.nodes:
for d in n.dofs:
if d.name=="Displacement":
outline.append( (n.position.x + d.value[0],
n.position.y + d.value[1],
0.0) )
break
else:
outline.append( (n.position.x, n.position.y,0.0) )
outline.append(outline[0])
visual.curve(frame=frame,pos=outline)
return frame
def draw(self):
import visual
frame = visual.frame()
outline = visual.curve(frame=frame,
pos=[(0.0,0.0,0.0),(1.0,0.0,0.0),
(1.0,1.0,0.0),(0.0,1.0,0.0),
(0.0,0.0,0.0)],color=visual.color.red)
for e in self.elements:
outline = []
for n in e.nodes:
for d in n.dofs:
if d.name=="Displacement":
outline.append( (n.position.x + d.value[0],
n.position.y + d.value[1],
0.0) )
break
else:
outline.append( (n.position.x, n.position.y,0.0) )
outline.append(outline[0])
visual.curve(frame=frame,pos=outline)
return frame
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 __init__(self, background=None, ambient=None, show_axis=True):
super(Visualiser, self).__init__()
if not VISUAL_INSTALLED:
return
if background is None:
background = (0.957, 0.957, 1)
if ambient is None:
ambient = 0.5
self.display = visual.display(title='PVTrace', x=0, y=0, width=800, height=600, background=background,
ambient=ambient)
self.display.bind('keydown', self.keyInput)
self.display.exit = False
self.display.center = (0.025, 0.015, 0)
self.display.forward = (0, 0.83205, -0.5547)
show_axis = False
if show_axis:
visual.curve(pos=[(0, 0, 0), (.08, 0, 0)], radius=0.0005, color=visual.color.red)
visual.curve(pos=[(0, 0, 0), (0, .07, 0)], radius=0.0005, color=visual.color.green)
visual.curve(pos=[(0, 0, 0), (0, 0, .08)], radius=0.0005, color=visual.color.blue)
visual.label(pos=(.09, 0, 0), text='X', background=visual.color.red, linecolor=visual.color.red)
visual.label(pos=(0, .08, 0), text='Y', background=visual.color.green, linecolor=visual.color.green)
visual.label(pos=(0, 0, .07), text='Z', background=visual.color.blue, linecolor=visual.color.blue)
def update_grid():
delete_current_grid()
if not showSpan:
return
global span_frame
span_frame = visual.frame()
vecs = map(lambda i: visual.vector(vectors[i].axis) * span_fact, selected)
for v in vecs:
rest = vecs[0:len(vecs)] # deep copy
rest.remove(v)
all_sums = all_sums_comb(rest)
for aSum in all_sums:
visual.curve(frame=span_frame,
pos=[aSum, aSum + v],
color=span_color)
if not is_span_positive:
visual.curve(frame=span_frame,
pos=[aSum, aSum - v],
color=span_color)
def input(self,data):
fft = data['fft']
if (len(self.curves) > self.maxlen):
todel = self.curves.pop()
todel.visible = False
del todel
for oldcurve in self.curves:
for point in range(len(oldcurve.pos)):
oldcurve.pos[point][2] -= self.step
y = []
for point in fft:
y.append(point)
y.append(point)
curve = visual.curve(color=visual.color.white, display=self.g, radius=0)
if data.has_key('dominantbucket'):
dominant = data['dominantbucket']
else:
dominant = False
if (self.lastdominant != dominant and self.label):
self.label.visible = False
del self.label
self.label = False
for point in zip(range(len(fft)),fft):
if dominant and (point[0] + 2) > dominant and (point[0] - 2) < dominant:
r = 1
g = 0
b = 0
if (self.lastdominant != dominant and dominant == point[0]):
self.label = visual.label(pos=(point[0],10,0),
text=str(data['note']), xoffset=20,
yoffset=12,
height=10, border=6,
font='sans')
else:
r = g = b = point[1] / 3
curve.append(pos=(point[0],point[1],0), color=(r,g,b))
self.lastdominant = dominant
self.curves.insert(0,curve)
def main(): visual.rate(10) a, b, c = 0.2, 0.2, 5.7 x, y, z = 0.0, 0.0, 0.0 dt = 0.01 system = Roessler(a, b, c, x, y, z, dt) num_curves = 100 for i in range(num_curves): curve = visual.curve(color = visual.color.white) curve_max_points = 1000 # "skipping points" otherwise for j in range(curve_max_points): system.advance() x, y, z = system.get_xyz() curve.append(pos = (x, y, z))
def main():
visual.rate(10)
a, b, c = 0.2, 0.2, 5.7
x, y, z = 0.0, 0.0, 0.0
dt = 0.01
system = Roessler(a, b, c, x, y, z, dt)
num_curves = 100
for i in range(num_curves):
curve = visual.curve(color=visual.color.white)
curve_max_points = 1000 # "skipping points" otherwise
for j in range(curve_max_points):
system.advance()
x, y, z = system.get_xyz()
curve.append(pos=(x, y, z))
def main():
visual.rate(100)
beta, rho, sigma = 8.0 / 3.0, 28.0, 10.0
x, y, z = 5.0, 5.0, 5.0
dt = 0.002
system = Lorentz(beta, rho, sigma, x, y, z, dt)
num_curves = 30
for i in range(num_curves):
curve = visual.curve(color=visual.color.white)
curve_max_points = 1000 # "skipping points" otherwise
for j in range(curve_max_points):
system.advance()
x, y, z = system.get_xyz()
curve.append(pos=(x, y, z))
def main(): visual.rate(100) beta, rho, sigma = 8.0/3.0, 28.0, 10.0 x, y, z = 5.0, 5.0, 5.0 dt = 0.002 system = Lorentz(beta, rho, sigma, x, y, z, dt) num_curves = 30 for i in range(num_curves): curve = visual.curve(color = visual.color.white) curve_max_points = 1000 # "skipping points" otherwise for j in range(curve_max_points): system.advance() x, y, z = system.get_xyz() curve.append(pos = (x, y, z))
def frame(self, sign):
self.glass = curve(pos=[(sign * self.time, -self.time * 1.1, 0),
(sign * self.time * 0.05, -self.time * 0.1, 0),
(sign * self.time * 0.05, self.time * 0.1, 0),
(sign * self.time, self.time * 1.1, 0),
(sign * self.time, self.time * 1.15, 0)],
radius=self.time * .025)
self.base = cylinder(pos=(0, sign * self.time * 1.15, 0),
axis=(0, 1, 0),
length=self.time * 0.1,
radius=self.time * 1.2,
color=(.66, .46, .13))
self.pole = cylinder(pos=(sign * self.time, -self.time * 1.1, 0),
axis=(0, 1, 0),
length=self.time * 2.3,
radius=self.time * 0.06,
color=(.66, .46, .13))
def f(alfa, v0):
vel_fotogramas = 25
g = 9.81
v0x = v0 * np.cos(np.deg2rad(alfa))
v0z = v0 * np.sin(np.deg2rad(alfa))
t_total = 2 * v0z / g
x_final = v0x * t_total
suelo = vs.box(pos=(x_final / 2., -1, 0),
size=(x_final, 1, 10),
color=vs.color.green)
canyon = vs.cylinder(pos=(0, 0, 0),
axis=(2 * np.cos(np.deg2rad(alfa)),
2 * np.sin(np.deg2rad(alfa)), 0))
bola = vs.sphere(pos=(0, 0, 0))
bola.trail = vs.curve(color=bola.color)
flecha = vs.arrow(pos=(0, 0, 0), axis=(v0x, v0z, 0), color=vs.color.yellow)
labelx = vs.label(pos=bola.pos,
text='posicion x = 0 m',
xoffset=1,
yoffset=80,
space=bola.radius,
font='sans',
box=False,
height=10)
labely = vs.label(pos=bola.pos,
text='posicion y = 0 m',
xoffset=1,
yoffset=40,
space=bola.radius,
font='sans',
box=False,
height=10)
t = 0
while t <= t_total:
bola.pos = (v0x * t, v0z * t - 0.5 * g * t**2, 0)
flecha.pos = (v0x * t, v0z * t - 0.5 * g * t**2, 0)
flecha.axis = (v0x, v0z - g * t, 0)
bola.trail.append(pos=bola.pos)
labelx.pos = bola.pos
labelx.text = 'posicion x = %s m' % str(v0x * t)
labely.pos = bola.pos
labely.text = 'posicion y = %s m' % str(v0z * t - 0.5 * g * t**2)
t = t + t_total / 100.
vs.rate(vel_fotogramas)
return x_final
def __init__(self, background=(0,0,0), ambient=1.):
super(Visualiser, self).__init__()
if not VISUAL_INSTALLED:
return
self.display = visual.display(title='PVTrace', x=0, y=0, width=800, height=600, background=(0.957, 0.957, 1), ambient=0.5)
self.display.exit = False
visual.curve(pos=[(0,0,0), (.2,0,0)], radius=0.001, color=visual.color.red)
visual.curve(pos=[(0,0,0), (0,.2,0)], radius=0.001, color=visual.color.green)
visual.curve(pos=[(0,0,0), (0,0,.2)], radius=0.001, color=visual.color.blue)
visual.label(pos=(.22, 0, 0), text='X', linecolor=visual.color.red)
visual.label(pos=(0, .22, 0), text='Y', linecolor=visual.color.green)
visual.label(pos=(0, 0, .22), text='Z', linecolor=visual.color.blue)
background=black,
forward=(1, 0, 0))
# Inertial reference frame arrows
N = [
arrow(pos=NO, axis=N1, color=red),
arrow(pos=NO, axis=N2, color=green),
arrow(pos=NO, axis=N3, color=blue)
]
torus = ring(pos=CO[0], axis=B2[0], radius=r1, thickness=r2, color=blue)
# Arrows for body fixed coordinates in plane of torus
c1 = arrow(pos=CO[0], axis=C1[0], up=C3[0], color=red)
c3 = arrow(pos=CO[0], axis=C3[0], up=C1[0], color=green)
# Ground contact path
trail = curve()
trail.append(pos=(x[0, 3], x[0, 4], 0.0), color=white)
i = 1
while i < n:
torus.pos = CO[i]
torus.axis = B2[i]
c1.pos = CO[i]
c3.pos = CO[i]
c1.axis = C1[i]
c3.axis = C3[i]
c1.up = C3[i]
c3.up = C1[i]
trail.append(pos=(x[i, 3], x[i, 4], 0.0), color=white)
i += 1
rate(k / ts)
s += mag(r[i+1]-r[i])
return s
# Choose N city locations and calculate the initial distance
r = empty([N+1,2],float)
for i in range(N):
r[i,0] = random()
r[i,1] = random()
r[N] = r[0]
D = distance()
# Set up the graphics
display(center=[0.5,0.5])
for i in range(N):
sphere(pos=r[i],radius=R)
l = curve(pos=r,radius=R/2)
# Main loop
t = 0
T = Tmax
while T>Tmin:
# Cooling
t += 1
T = Tmax*exp(-t/tau)
# Update the visualization every 100 moves
if t%100==0:
l.pos = r
rate(25)
def vPythSim(a, e, O, I, w, M):
visual.scene.autoscale = False
#Asteroid
a = a
e = e
O = radians(O)
I = radians(I)
w = radians(w)
M = radians(M)
positionEq = equatorial(eclipticPos(position(a, newton(M, e), e), O, I, w),
radians(23.437))
rVector = visual.vector(0, 0, 0)
rVector.x = positionEq[0]
rVector.y = positionEq[1]
rVector.z = positionEq[2]
#Earth
earthA = 1.000703137122473
earthe = 1.599048849057274E-02
earthO = radians(1.652211903265974E+02)
earthI = radians(2.744957205807269E-03)
earthW = radians(2.973932488195502E+02)
earthM = radians(2.061751020668477E+02)
earthPos = equatorial(
eclipticPos(position(earthA, newton(earthM, earthe), earthe), earthO,
earthI, earthW), radians(23.437))
erVector = visual.vector(0, 0, 0)
erVector.x = earthPos[0]
erVector.y = earthPos[1]
erVector.z = earthPos[2]
## def MVcalc(a,k,mu,T):
## n=k*sqrt(mu/a**3)
## return n*T
##
## def Mcalc2(a,T,Mo,tOld):
## n=0.01720209894*sqrt(1.000000/a**3)
## return n*(T-tOld)+Mo
t = 0
#Where 0 corresponds to the JD of the central observation (where simulation starts)
dt = 0.5
asteroid = visual.sphere(pos=rVector * 150, radius=(5), color=color.white)
asteroid.trail = visual.curve(color=color.white)
Earth = visual.sphere(pos=erVector * 150,
radius=(15),
material=materials.earth)
Earth.trail = visual.curve(color=color.white)
sun = visual.sphere(pos=(0, 0, 0), radius=(50), color=color.yellow)
while (1 == 1):
visual.rate(100)
t = t + 1
M = MVcalc(a, 0.01720209894, 1, t)
E = newton(M, e)
positionEq = equatorial(eclipticPos(position(a, E, e), O, I, w),
radians(23.437))
rVector.x = positionEq[0]
rVector.y = positionEq[1]
rVector.z = positionEq[2]
asteroid.pos = rVector * 150
asteroid.trail.append(pos=asteroid.pos)
earthM = MVcalc(earthA, 0.01720209894, 1, t)
earthE = newton(earthM, earthe)
earthPos = equatorial(
eclipticPos(position(earthA, earthE, earthe), earthO, earthI,
earthW), radians(23.437))
erVector.x = earthPos[0]
erVector.y = earthPos[1]
erVector.z = earthPos[2]
Earth.pos = erVector * 150
Earth.trail.append(pos=Earth.pos)
return True
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
a, b, w = 1., 0.5, 0.125 # rink size, goal width
q, qcor, qmid, qcen = -1.0, 1.0, -2., 2. # Qs: puck, cor., mid, cen.
Q = [qcor, qmid, qcor, qcor, qmid, qcor, qcen] # charges, locations
loc = [[-a, b], [0, b], [a, b], [a, -b], [0, -b], [-a, -b], [0, 0]]
scene = vp.display(title='Electric hockey', background=(.2, .5, 1))
puck = vp.sphere(pos=(-a, 0, 0), radius=0.05, make_trail=True) # trail
rink = vp.curve(pos=loc[:-1] + [loc[0]], radius=0.01) # closed curve
goalL = vp.curve(pos=[(-a, w, 0), (-a, -w, 0)], color=(0, 1, 0), radius=.02)
goalR = vp.curve(pos=[(a, w, 0), (a, -w, 0)], color=(0, 1, 0), radius=.02)
for i in range(len(loc)): # charges, red if Q>0, blue if Q<0
color = (1, 0, 0) if Q[i] > 0 else (0, 0, 1)
vp.sphere(pos=loc[i], radius=0.05, color=color)
v, theta = input('enter speed, theta; eg, 2.2, 19:') # try 2.2, 18.5
v, theta = min(4, v), max(1, theta) * np.pi / 180. # check valid input
Y = np.array([[-a, 0], [v * np.cos(theta), v * np.sin(theta)]])
while True:
vp.rate(200)
Y = ode.RK45n(hockey, Y, t=0., h=0.002)
x, y = Y[0][0], Y[0][1]
if (abs(x) > a or abs(y) > b):
txt = 'Goal!' if (x > 0 and abs(y) < w) else 'Miss!'
Spyder Editor
This is a temporary script file.
"""
############################################################
#Moving Vpython objects around screen using SUVAT equations#
#Fahad Chohan 30/11/2015 #
############################################################
# Importing numpy and functions for annimating a sphere
from visual import sphere, curve, color, display, rate
import numpy as np
# set up the scene
scene = display(x=50, y=50, width=640, height=480, center=(20, 0, 0))
ground = curve(pos=[(-5, 0, 0), (50, 0, 0)], color=color.green)
# initial ball coordinates (metres)
x0 = 0.0
y0 = 0.0
y = y0
g = 9.8 # gravitational acceleration, m/s2
dt = 0.01 # time interval for loop, in seconds
x = 0.0
# input initial angle and velocity
dtheta = float(raw_input("Input the initial angle in degrees: "))
theta = np.radians(dtheta)
theta1 = theta
v0 = float(raw_input("Input the initial velocity in metres/second: "))
e = float(raw_input("Input the value for coefficient of restitution: "))
def draw_bonds(mol):
for l in mol.bonds:
b = curve(pos=(mol.atoms[l[0] - 1].xyz[0], mol.atoms[l[0] - 1].xyz[1],
mol.atoms[l[0] - 1].xyz[2]))
b.append(mol.atoms[l[1] - 1].xyz)
v0x = v0 * np.cos(alfa)
v0z = v0 * np.sin(alfa)
t_total = Tv
x_final = 6.75
## Empezamos con visual python (vpython)
## Creamos el 'suelo'
suelo = vs.box(pos=(x_final / 2., -1, 0),
size=(x_final, 1, 10),
color=vs.color.green)
## Creamos el 'canon'
canyon = vs.cylinder(pos=(0, 0, 0),
axis=(2 * np.cos(alfa), 2 * np.sin(alfa), 0),
size=(0, 0, 0, 0))
## Creamos el proyectil y una linea que dejara la estela del proyectil
bola = vs.sphere(pos=(0, 0, 0), radius=0.5, color=vs.color.magenta)
bola.trail = vs.curve(color=vs.color.cyan)
## Creamos el vector que indica la direccion del movimiento (vector velocidad)
flecha = vs.arrow(pos=(0, 0, 0),
axis=(v0x, v0z, 0),
color=vs.color.yellow,
size=(0))
## texto (ponemos etiquetas para informar de la posicion del proyectil)
labelx = vs.label(pos=bola.pos,
text='posicion x = 0 m',
xoffset=1,
yoffset=80,
space=bola.radius,
font='sans',
box=False,
height=10)
labely = vs.label(pos=bola.pos,
def draw(self):
self.f = visual.frame()
self.vis = visual.curve(frame=self.f, x=[0, 1, 2])
Primitive.draw(self)
