def draw_graph_lagrange():
# przygotowanie wykresu
gd = graph(title='Interpolacja Lagrange\'a')
f1 = gcurve(graph=gd, color=color.cyan)
dots = gdots(graph=gd, color=color.red)
f2 = gcurve(graph=gd, color=color.green)
# tablica do przechowywania wylosowanych punktów
initial_points = []
# zmienna pomocnicza używana przy losowaniu punktów wielomianu
index = 0
# wyliczanie wartości funkcji podstawowej w tym przypadku cos(2*x) * exp(-0.2 * x)
field_end = 8.05
for x in arange(0, field_end, 0.1):
y = cos(2 * x) * exp(-0.2 * x)
f1.plot(x, y)
#losowanie punktów do wyliczania interpolacji - odbywa kiedy x znajduje się w przedziale 1..field_end-1
if 1 < x <= field_end - 1 and index % 2 == 0 and bool(getrandbits(1)):
initial_points.append({'x': x, 'y': y})
dots.plot(x, y)
index = index + 1
# wyliczanie i rysowanie interpolacji
for point in lagrange_interpolation(initial_points, field_end):
f2.plot(point['x'], point['y'])
def count():
# algroytm działa także dla innych wielkości kwadratu r=a/2
r = 0.5
gd = graph(ymin=0, ymax=2 * r + 0.5, xmin=0, xmax=2 * r + 0.5)
f1 = gcurve(graph=gd, color=color.cyan)
f2 = gcurve(graph=gd, color=color.cyan)
dots = gdots(graph=gd, color=color.red, radius=2)
for x in arange(0, 2 * r + 0.001, 0.01):
f1.plot(x, circle_point_lower(x, r))
f2.plot(x, circle_point_upper(x, r))
points_count = randrange(200, 300)
ok_points = 0
while x <= points_count:
x = x + 1
point = draw_point(2 * r)
dots.plot(point[0], point[1])
if circle_point_upper(point[0], r) >= point[1] >= circle_point_lower(
point[0], r):
ok_points = ok_points + 1
field = ok_points / points_count
pi = field / (r**2)
f1.label = 'pi = ' + str(pi)
f2.label = 'field = ' + str(field)
gd.height = 450
gd.width = 450
def main():
parameters = {
"birth_rate": 0.00,
"death_rate": 0.00,
"rate_of_transmission": 0.00004,
"rate_of_incubation": 1,
"rate_of_recovery": 1 / 14,
"rate_of_loss_of_immunity": 0.00003,
"rate_of_vaccination": 0,
"rate_of_treatment": 0
}
pop_susceptible = 50000000 # number susceptible: Not yet infected.
pop_exposed = 500000 # number exposed
pop_infectious = 200 # number infected: Ongoing disease.
pop_recovered = 100 # number recovered: Gained immunity, isolated, or dead.
vector_population = [
pop_susceptible, pop_exposed, pop_infectious, pop_recovered
]
# Create graphs.
s_plot = vpython.gcurve(color=vpython.color.blue, label="% susceptible")
i_plot = vpython.gcurve(color=vpython.color.red, label="% infected")
r_plot = vpython.gcurve(color=vpython.color.green, label="% recovered")
e_plot = vpython.gcurve(color=vpython.color.orange, label="% exposed")
time = 0
tmax = 1000
dt = 0.1
while time < tmax:
# Use RK4 method to determine the new vector_population.
k1 = derivs(time, vector_population, parameters)
k2 = derivs(time + dt / 2, add(vector_population, mult(k1, 0.5)),
parameters)
k3 = derivs(time + dt / 2, add(vector_population, mult(k2, 0.5)),
parameters)
k4 = derivs(time + dt, add(vector_population, k3), parameters)
vector_population = add(
vector_population,
mult(
add(
mult(k1, 1 / 6),
add(mult(k2, 1 / 3), add(mult(k3, 1 / 3),
mult(k4, 1 / 6)))), dt))
print(vector_population)
# plot using vpython
vpython.rate(50) # fps of graph up§te
s_plot.plot(time, vector_population[0])
e_plot.plot(time, vector_population[1])
i_plot.plot(time, vector_population[2])
r_plot.plot(time, vector_population[3])
time += dt
def init_graphs():
vpython.graph(
title="Energy of Earth's Orbit",
xtitle="Time (days)",
ytitle="Energy (J)",
fast=False,
)
return {
"potential": vpython.gcurve(color=vpython.color.blue, width=2),
"kinetic": vpython.gcurve(color=vpython.color.red, width=2),
"total": vpython.gcurve(color=vpython.color.magenta, width=2),
}
def draw_graph(start, end, n=10):
f1 = gcurve(graph=graph(title='Metoda trapezów'), color=color.cyan)
for i in arange(start, end + 0.001, 0.01):
x = round(i, 3)
f1.plot(x, integral_function(x))
f1.label = 'field = ' + str(2 * integral(start, end, n))
def init_graph():
vpython.graph(
title="Ball on a Spring",
xtitle="Time (s)",
ytitle="Displacement (m)",
fast=False,
)
return vpython.gcurve(color=vpython.color.red, width=2)
def plot_supplimentary_information(self):
self.plots = True
atom_position_graph = vp.graph(title='Absolute Displacement of Red Atom',
xtitle=r't [s]', ytitle=r'|r(t)-vector| [m]', fast=True,
legend=True)
atom_velocity_graph = vp.graph(title='Absolute Speed of Red Atom', xtitle=r't [s]', ytitle=r'|r(t)-dot-vector| [m/s]', fast=True,
legend=True)
atom_phasespace = vp.graph(title='Phase space of Red Atom', ytitle=r'|r(t)-vector| [m]', fast=True,
legend=True, xtitle=r'|r(t)-dot-vector| [m/s]')
label_constant = "Spring Constant: {} N/m"
self.atom_position_points = vp.gcurve(graph=atom_position_graph, color=vp.color.red, size=0.1,
label=label_constant.format(self.atom_list[0].force_constant))
self.atom_velocity_points = vp.gcurve(graph=atom_velocity_graph, color=vp.color.blue, size=0.1,
label=label_constant.format(self.atom_list[0].force_constant))
self.atom_phasespace_points = vp.gcurve(graph=atom_phasespace, color=vp.color.green, size=0.1,
label=label_constant.format(self.atom_list[0].force_constant))
def setup_display():
scene = vp.canvas(x=0,
y=0,
width=400,
height=400,
userzoom=False,
userspin=True,
autoscale=False,
center=vp.vector(0, 0, 3),
foreground=vp.color.white,
background=vp.color.black)
vp.arrow(pos=vp.vector(0, 0, 0), axis=vp.vector(10, 0, 0), shaftwidth=0.3)
vp.arrow(pos=vp.vector(0, 0, 0), axis=vp.vector(0, 10, 0), shaftwidth=0.3)
plt_x = vp.gcurve(color=vp.color.red, size=2)
plt_y = vp.gcurve(color=vp.color.red, size=2)
return scene, plt_x, plt_y
def newton_czybyszew(nodes_amount):
gd = graph(title='Interpolacja Newtona\'a')
f1 = gcurve(graph=gd, color=color.cyan)
dots = gdots(graph=gd, color=color.red)
f2 = gcurve(graph=gd, color=color.green)
# wyliczanie wartości funkcji podstawowej w tym przypadku cos(2*x) * exp(-0.2 * x)
field_end = 8.05
for x in arange(0, field_end, 0.1):
y = origin_newton_function(x)
f1.plot(x, y)
# tablica do przechowywania wylosowanych punktów
initial_points = []
for x in czybyszew_points(nodes_amount, 0, field_end):
y = origin_newton_function(x)
dots.plot(x, y)
initial_points.append({'x': x, 'y': y})
# wyliczanie i rysowanie interpolacji
for point in newton_interpolation(initial_points, field_end):
f2.plot(point['x'], point['y'])
def draw_function_average(start, end, tries=200):
g = graph(title='Metoda próbkowania średniej')
f1 = gcurve(graph=g, color=color.cyan)
dots = gdots(graph=g, color=color.red)
points = count_points(start, end)
for point in points['points']:
f1.plot(point)
sampling = average_sampling(start, end, tries)
for point in sampling['points']:
dots.plot(point)
f1.label = '2 * wartość całki= ' + str(2 * sampling['value'])
def init_beads(nbeads):
beads = []
for i in range(nbeads):
theta_start = 180 * DEG * (i + 0.5) / nbeads
bead = vpython.sphere(
pos=vpython.vector(wire_x(theta_start), wire_y(theta_start), 0),
radius=0.1 * WHEEL_RADIUS,
color=COLORS[i],
)
# Use the bead object to keep track of all the dead's data, not just
# the visual stuff.
bead.v = vpython.vector(0, 0, 0)
bead.graph = vpython.gcurve(color=COLORS[i], width=2)
beads.append(bead)
return beads
def _make_plot(theta, display_width, display_height):
""" Makes the VPython graph.
:return: The graph object.
"""
graph(width=display_width / 2 - 10,
height=display_height,
background=color.white,
align='right',
xtitle='Time (s)',
ytitle='Angle (\u00b0)')
f = gcurve(color=color.red, dot=True, interval=100)
f.plot(0, math.degrees(theta))
return f
def draw_function_simple(start, end, tries=200):
g = graph(title='Metoda prostego próbkowania')
f1 = gcurve(graph=g, color=color.cyan)
dots = gdots(graph=g, color=color.red)
points = count_points(start, end)
for point in points['points']:
f1.plot(point)
correct_points = 0
for _ in range(0, tries):
point = draw_point(start, end - start)
dots.plot(point)
if point[1] <= integral_function(point[0]):
correct_points = correct_points + 1
# max_val jest największą wartością funkcji,
# odpowiada zmiennej H która musi być większa od f(x) dlatego koryguję o 0.1
p_gross = count_gross_field(end - start, points['max_val'] + 0.0001)
p = correct_points / tries * p_gross
f1.label = '2 * wartość całki= ' + str(2 * p)
dots.label = 'pole całkowite= ' + str(p_gross)
def plotCurveXY(x, y):
stage = vp.canvas()
f1 = vp.gcurve(color=vp.color.blue)
for n in range(y.shape[0]):
f1.plot(pos=(x[n], y[n]))
import vpython as vp
from robot_imu import RobotImu, ImuFusion
from delta_timer import DeltaTimer
import imu_settings
imu = RobotImu(gyro_offsets=imu_settings.gyro_offsets,
mag_offsets=imu_settings.mag_offsets)
fusion = ImuFusion(imu)
vp.graph(xmin=0, xmax=60, scroll=True)
graph_pitch = vp.gcurve(color=vp.color.red)
graph_roll = vp.gcurve(color=vp.color.green)
graph_yaw = vp.gcurve(color=vp.color.blue)
timer = DeltaTimer()
while True:
vp.rate(100)
dt, elapsed = timer.update()
fusion.update(dt)
graph_pitch.plot(elapsed, fusion.pitch)
graph_roll.plot(elapsed, fusion.roll)
graph_yaw.plot(elapsed, fusion.yaw)
import vpython as vp
import logging
import time
from robot_imu import RobotImu
logging.basicConfig(level=logging.INFO)
imu = RobotImu()
pr = vp.graph(xmin=0, xmax=60, scroll=True)
graph_pitch = vp.gcurve(color=vp.color.red, graph=pr)
graph_roll = vp.gcurve(color=vp.color.green, graph=pr)
xyz = vp.graph(xmin=0, xmax=60, scroll=True)
graph_x = vp.gcurve(color=vp.color.orange, graph=xyz)
graph_y = vp.gcurve(color=vp.color.cyan, graph=xyz)
graph_z = vp.gcurve(color=vp.color.purple, graph=xyz)
start = time.time()
while True:
vp.rate(100)
elapsed = time.time() - start
pitch, roll = imu.read_accelerometer_pitch_and_roll()
raw_accel = imu.read_accelerometer()
graph_pitch.plot(elapsed, pitch)
graph_roll.plot(elapsed, roll)
print(f"Pitch: {pitch:.2f}, Roll: {roll:.2f}")
graph_x.plot(elapsed, raw_accel.x)
graph_y.plot(elapsed, raw_accel.y)
graph_z.plot(elapsed, raw_accel.z)
Xmax = 40.
Xmin = 0.25
step = 0.1
order = 10
start = 50
graph1 = vp.display(width=500,
height=500,
title="Spherical Bessel \
L=1 (red) 10",
xtitle="x",
xmin=Xmin,
xmax=Xmax,
ymin=0.2,
ymax=0.5)
funct1 = vp.gcurve(color=color.red)
funct2 = vp.gcurve(color=color.green)
def down(x, n, m): # Recursion woo!
"""
Moving downward in the pyramidal method
we apply the Bessel equation to find the
range of the Bessel function
"""
j = np.zeros((start + 2), float) # initialize zeros
j[m + 1] = j[m] = 1 # iterate the next element of j as 1
for k in range(m, 0, 01):
j[k - 1] = (
(2 * k + 1) / x) * j[k] - j[k + 1] # apply the iterative procedure
scale = (np.sin(x) / x) / j[0] # scale the j array appropriately
def optimized_animate_TRod(y, dt, rb):
""" Animates RigidBody's vpython object (optimized version).
TODO: To finally optimize, make sure vp.rate is consistent with real time and make sure to only display
results needed. Exclude non-displayed results that are left out because of frame-rate."""
frame_rate = dt**-1
rb.create_vpython_object()
animation_graph = vp.graph(scroll=True,
fast=True,
xmin=-5,
xmax=5,
ymin=-2.5,
ymax=2.5)
omega1_plot = vp.gcurve(color=vp.color.red)
omega2_plot = vp.gcurve(color=vp.color.green)
omega3_plot = vp.gcurve(color=vp.color.blue)
plot_interval = 1
t = 0
tot_axes = len(rb.R)
omegas1 = y[:, 0].copy()
omegas2 = y[:, 1].copy()
omegas3 = y[:, 2].copy()
np_axes = y[:, 3:12].copy()
np_axes = np_axes.reshape((len(np_axes), 3, 3))
vp_axes = []
for R in np_axes:
vp_R = []
for axis in R:
vp_R.append(vp.vector(*axis))
vp_axes.append(vp_R)
for k in range(len(y)):
vp.rate(frame_rate) # set framerate
omega1 = omegas1[k]
omega2 = omegas2[k]
omega3 = omegas3[k]
R = vp_axes[k]
# Plot curves.
if not k % plot_interval: # Ex: If plot_interval = 3, only plot every 3rd point.
omega1_plot.plot(t, omega1)
omega2_plot.plot(t, omega2)
omega3_plot.plot(t, omega3)
t += dt
# Loop over axes and rotate object and arrows.
# Rotate x_arrow
old_length = rb.vp_object_axes[0].length
rb.vp_object_axes[0].axis = R[0]
rb.vp_object_axes[0].length = old_length
# Rotate y_arrow
old_length = rb.vp_object_axes[1].length
rb.vp_object_axes[1].axis = R[1]
rb.vp_object_axes[1].length = old_length
# Rotate z_arrow
old_length = rb.vp_object_axes[2].length
rb.vp_object_axes[2].axis = R[2]
rb.vp_object_axes[2].length = old_length
# # Rotation version (don't use both axis-setting and rotation)
# rb.vp_object.rotate(angle=omega1*dt, axis=R[0])
# rb.vp_object.rotate(angle=omega2*dt, axis=R[1])
# rb.vp_object.rotate(angle=omega3*dt, axis=R[2])
# Axis-setting version (don't use both axis-setting and rotation)
rb.vp_object.axis = R[0]
rb.vp_object.up = R[1]
# Update angular momentum arrows.
L = rb.I_body @ np.array(
(omega1, omega2,
omega3)) # Do this calc. outside loop for better optimization.
L /= np.linalg.norm(L) * 1 / 5
L_x = np.zeros(3)
L_x[0] = L[0]
L_y = np.zeros(3)
L_y[1] = L[1]
L_z = np.zeros(3)
L_z[2] = L[2]
rb.L_arrow.axis = vp.vector(*L)
rb.L_components[0].axis = vp.vector(*L_x)
rb.L_components[1].axis = vp.vector(*L_y)
rb.L_components[
1].pos = rb.L_components[0].pos + rb.L_components[0].axis
rb.L_components[2].axis = vp.vector(*L_z)
rb.L_components[
2].pos = rb.L_components[1].pos + rb.L_components[1].axis
import vpython as vp
import time
from robot_imu import RobotImu
import imu_settings
imu = RobotImu(gyro_offsets=imu_settings.gyro_offsets)
vp.graph(xmin=0, xmax=60, ymax=360, ymin=-360, scroll=True)
graph_x = vp.gcurve(color=vp.color.red)
graph_y = vp.gcurve(color=vp.color.green)
graph_z = vp.gcurve(color=vp.color.blue)
start = time.time()
while True:
vp.rate(100)
elapsed = time.time() - start
gyro = imu.read_gyroscope()
print(f"Gyro x: {gyro.x:.2f}, y: {gyro.y:.2f}, z: {gyro.z:.2f}")
graph_x.plot(elapsed, gyro.x)
graph_y.plot(elapsed, gyro.y)
graph_z.plot(elapsed, gyro.z)
vector(-d, d, -d),
vector(-d, d, d),
vector(d, d, d),
vector(d, d, -d),
vector(-d, d, -d)
])
vert1 = curve(color=gray, radius=r)
vert2 = curve(color=gray, radius=r)
vert3 = curve(color=gray, radius=r)
vert4 = curve(color=gray, radius=r)
vert1.append([vector(-d, -d, -d), vector(-d, d, -d)])
vert2.append([vector(-d, -d, d), vector(-d, d, d)])
vert3.append([vector(d, -d, d), vector(d, d, d)])
vert4.append([vector(d, -d, -d), vector(d, d, -d)])
grafico0 = gcurve(color=color.cyan)
grafico1 = gcurve(color=color.red)
#campionamento temporale
dt = 0.005
t = 0
while t < 2:
rate(50)
#controlla se ci sono collisioni con il polline
for particella in particelle:
distance = mag(particella.pos - polline.pos)
if distance < particella.radius + polline.radius:
ball.velocity = initial_velocity
ball.mass = 0.1
rod = vp.cylinder(pos=initial_position, axis=-ball.pos, radius=0.1)
dt = 0.005
t = 0
T = 20
# k = 10
k = lambda t: np.sin(t)
d = 4
g = -9.81 * 0
drag_coefficient = 0.001 * 0
# A plot
kinetic = vp.gcurve(color=vp.color.blue)
while t < T:
vp.rate(100)
relative_displacement = rod.length - d
ball_force = -k(t) * relative_displacement * ball.pos.norm()
ball_force.y += g
ball_force -= drag_coefficient * ball.velocity.mag**2 * ball.velocity.norm(
)
acceleration = ball_force / ball.mass
ball.velocity += acceleration * dt
kinetic_energy = 0.5 * ball.mass * ball.velocity.mag**2
kinetic.plot(t, kinetic_energy)
ball.pos += ball.velocity * dt
rod.pos = ball.pos
rod.axis = -ball.pos
from vpython import box, sphere, color, vector, rate, dot, graph, gcurve
import copy
ground = box(color=color.red, size=vector(22, 1, 1), pos=vector(0, -1.5, 0))
top = box(color=color.red, size=vector(22, 1, 1), pos=vector(0, 19.5, 0))
left = box(color=color.red, size=vector(1, 22, 1), pos=vector(-11, 9, 0))
right = box(color=color.red, size=vector(1, 22, 1), pos=vector(11, 9, 0))
energy = gcurve()
potential = gcurve(color=color.blue)
kinetic = gcurve(color=color.red)
dt = 0.1
g = 9.8
s = sphere()
s.pos = vector(-7, 10, 0)
#s.velocity = vector(5, 19.2, 0)
s.velocity = vector(0, 0, 0)
s.prev_pos = s.pos - (s.velocity * dt)
s.accel = vector(0, -g, 0)
s.mass = 2.0
t = 0
while t < 10:
kinetic_energy = 0.5 * s.mass * dot(s.velocity, s.velocity)
potential_energy = s.mass * 9.8 * dot(s.pos, vector(0, 1, 0))
kinetic.plot(pos=(t, kinetic_energy))
potential.plot(pos=(t, potential_energy))
import vpython as vp
from robot_imu import RobotImu
from delta_timer import DeltaTimer
import imu_settings
imu = RobotImu(mag_offsets=imu_settings.mag_offsets)
vp.graph(xmin=0, xmax=60, scroll=True)
graph_yaw = vp.gcurve(color=vp.color.blue)
timer = DeltaTimer()
while True:
vp.rate(100)
dt, elapsed = timer.update()
mag = imu.read_magnetometer()
yaw = -vp.degrees(vp.atan2(mag.y, mag.x))
graph_yaw.plot(elapsed, yaw)
"""When running,
use VPYTHON_PORT=9020 VPYTHON_NOBROWSER=true"""
import vpython as vp
import time
import logging
from robot_imu import RobotImu
logging.basicConfig(level=logging.INFO)
imu = RobotImu()
vp.graph(xmin=0, xmax=60, scroll=True)
temp_graph = vp.gcurve()
start = time.time()
while True:
vp.rate(100)
temperature = imu.read_temperature()
logging.info("Temperature {}".format(temperature))
elapsed = time.time() - start
temp_graph.plot(elapsed, temperature)
def main():
box_size = 10
box_thickness = 1
ball_radius = 0.5
# Set the axis of each side to be a perpendicular unit vector pointing into
# the box. That'll allow us to handle all the walls in a loop, rather than
# spelling them out
axes = [
vpython.vector(1, 0, 0),
vpython.vector(-1, 0, 0),
vpython.vector(0, 1, 0),
]
box_sides = []
for axis in axes:
side = vpython.box(
pos=-0.5 * box_size * axis,
axis=axis,
height=box_size,
width=box_size,
)
box_sides.append(side)
vpython.arrow(
pos=-0.5 * box_size * axis,
axis=axis,
color=vpython.color.blue,
)
# Initial position chosen randomly inside the box
x0 = vpython.vector(
random.random() * box_size - 0.5 * box_size,
random.random() * box_size - 0.5 * box_size,
0,
)
# Initial velocity small enough that we should not escape
v_max = math.sqrt(-2 * GRAVITY * (0.5 * box_size - x0.y))
v0 = vpython.vector(
random.random() * v_max,
random.random() * v_max,
0,
)
# Initialize the ball. Python also lets us attach an extra attribute, in
# this case velocity, to the ball object.
ball = vpython.sphere(
pos=x0,
color=vpython.color.red,
radius=ball_radius,
)
ball.v = v0
ball.m = 1
# Set up the graph pane and each curve we want in it
vpython.graph(
title="Ball in a Box",
xtitle="Time (s)",
ytitle="Energy (J)",
fast=False,
)
graph_pot = vpython.gcurve(color=vpython.color.blue,
width=2,
label="Potential Energy")
graph_kin = vpython.gcurve(color=vpython.color.red,
width=2,
label="Kinetic Energy")
graph_tot = vpython.gcurve(color=vpython.color.magenta,
width=2,
label="Total Energy")
# Time loop! Handle gravity and collisions
t, dt, tmax = 0, 0.001, 10
while t < tmax:
t += dt
vpython.rate(1 / dt)
dvdt = -GRAVITY * vpython.vector(0, -1, 0)
ball.v += dvdt * dt
ball.pos += ball.v * dt
# Check for collisions
for side in box_sides:
# Vector from the center of the ball to the center of the wall
center_to_center = ball.pos - side.pos
# Project onto the wall's perpendicular unit vector to get distance
distance = center_to_center.dot(side.axis)
# If it's a collision, flip the component of the ball's velocity
# that's perpendicular to the wall
if distance < (ball.radius + 0.5 * box_thickness):
dv = -2 * side.axis.dot(ball.v)
ball.v += side.axis * dv
energy_pot = -ball.m * GRAVITY * ball.pos.y
energy_kin = 0.5 * ball.m * ball.v.dot(ball.v)
graph_pot.plot(t, energy_pot)
graph_kin.plot(t, energy_kin)
graph_tot.plot(t, energy_pot + energy_kin)
return
self._amp = delta
# create oscillator instance
osc = oscillator(RADIUS, initial_position, initial_velocity)
time = 0
vp.graph(scroll=True,
fast=False,
xmin=0,
xmax=50,
xtitle='times(s)',
ytitle='delta (m)')
g0 = vp.gcurve()
#g1 = vp.gcurve(color = vp.color.red)
while True:
vp.rate(100)
# add elastic force
delta = osc.mass.pos - rest_position
elastic_force = -(K * delta) / M
# add fluid resistance
dumping_force = -B * osc.mass.velocity
# add external force oscillating at angular frequency omega
external_force = F0 * np.cos(omega * time) * vp.vector(1, 0, 0)
return Rnew, Vnew
# compute net force
def force(R, V, mass):
return mass*G - 0.0*mass*V
# visualization stuff
#scene = vp.canvas(title='3D scene', center = vp.vector(0.0, 0.0, 0.0))
scene = vp.canvas(title='Parabolic motion')
scene.autoscale = True
ball = vp.sphere(pos=vp.vector(R0[0], R0[1], R0[2]), radius=0.01, color=vp.color.cyan)
ball.velocity = vp.vector(V0[0], V0[1], V0[2])
vscale = 0.02
varr = vp.arrow(pos=ball.pos, axis=vscale*ball.velocity, color=vp.color.yellow)
ball.trail = vp.curve(color=ball.color)
ypos = vp.gcurve(color=vp.color.cyan, dot=True)
yvel = vp.gcurve(color=vp.color.red, dot=True)
# initial conditions
Y = np.zeros(NSTEPS); VY = np.zeros(NSTEPS) # To save only Y coordinates, as function of time
Y[0] = R0[1]; VY[0] = V0[1]
R = R0; V = V0 ; F = force(R, V, MASS) # Value which changes at each time step
V = start_integration(V, F, MASS, DT) # Move Velocity from 0 to -dt/2
# main evolution loop
it = 1
while it < NSTEPS:
F = force(R, V, MASS)
R, V = integration(R, V, F, MASS, DT)
Y[it] = R[1]; VY[it] = V[1]
if R[1] < 0:
import random
import vpython as vp
"""
Spontaneous decay simulation using "sys.stdout.write("\a")" so that we hear an alert each time there is a decay.
"""
# initialize the parameters
lambda1 = 0.001
max = 200
time_max = 500
seed = random.seed(18203)
number = nloop = max
graph1 = vp.gdisplay(width=1000, height=1000, title="Spontaneous Decay", xtitle="Time",
ytitle="Number left", xmax=500, xmin=0, ymax=300, ymin=0)
decayfunction = vp.gcurve(color=color.green)
# decay that atom yo
for time in range(0, time_max+1):
# time loop
for atom in ranger(1, number+1)
decay = random.random()
if decay < lambda1:
nloop = nloop - 1 # Decay occurs
sys.stdout.write("\a")
number = nloop
decayfunction.plotpos=(time,number)
rate(30)
import vpython
e_graph = vpython.gcurve(color=vpython.color.blue)
def gforce(p1, p2):
# Calculate the gravitational force exerted on p1 by p2.
G = 1 # Change to 6.67e-11 to use real-world values.
# Calculate distance vector between p1 and p2.
r_vec = p1.pos - p2.pos
# Calculate magnitude of distance vector.
r_mag = vpython.mag(r_vec)
# Calcualte unit vector of distance vector.
r_hat = r_vec / r_mag
# Calculate force magnitude.
force_mag = G * p1.mass * p2.mass / r_mag**2
# Calculate force vector.
force_vec = -force_mag * r_hat
return force_vec
def main():
star = vpython.sphere(pos=vpython.vector(0, 0, 0),
radius=0.2,
color=vpython.color.yellow,
mass=1.0 * 1000,
momentum=vpython.vector(0, 0, 0),
make_trail=True)
planet_one = vpython.sphere(pos=vpython.vector(1, 0, 0),
v0x = v0 * np.cos(angle * np.pi / 180)
v0y = v0 * np.sin(angle * np.pi / 180)
T = 2 * v0y / g # time
H = v0y * voy / (2 * g) # height (vertical distance)
R = 2 * v0x * v0y / g # horizontal distance
graph1 = vp.gdisplay(
title="Projectile width (red)/without (yellow) Air Resistance",
xtitle="x",
ytitle="y",
xmax=R,
xmin=-R / 20,
ymax=8,
ymin=-6.0)
funct1 = vp.gcurve(color=color.red)
funct1 = vp.gcurve(color=color.yellow)
print("Frictionless T = " + str(T))
print("Frictionless H = " + str(H))
print("Frictionless R = " + str(R))
def plotNumeric(k):
"""
Plot the numeric solution to the projectile using individual values
for each variable.
"""
vx = v0 * np.cos(angle * np.pi / 180)
vy = v0 * np.sin(angle * np.pi / 180)
x = 0
