Inhoudsopgave

Inhoudsopgave
Tutorial 1
1.1 Bewegen zonder versnelling
1.2 Bewegen met constante versnelling
1.3 Bewegen met variabele versnelling 1
1.4 Bewegen met variabele versnelling 2
1.5 Bewegen met variabele versnelling 3
1.6 Bewegen in 2D
Tutorial 2
2.1 Massa-veer
2.2 Massa veer met zwaartekracht
2.3 Nieuwe integratiemethode / Odeint
2.4 Elastische botsing
2.5 Instantane botsing
Tutorial 3
w;3.1 Hovercraft 1
3.2 Hovercraft 2
3.3 Schijf aan een Veer (werkt niet volledig)
Opdracht 4
Sportauto
Blok valt op een veer?? 🙁:(
Massa-veer-demper
Vliegtuig
Tutorial 1

1.1 Bewegen zonder versnelling

import matplotlib.pyplot as plt

import numpy as np

dt = float(0.1)
t0 = float(0.0)
t1 = float(10.0)
x0 = float(1.2)
v0 = float(3.0)

t = np.linspace(0, 10, 101)

def analytisch(x0, v0, t):

v = v0
x = (v0*t) + x0
return (x, v)

def numeriek(x0, v0, t):

x = np.zeros(len(t))
v = np.zeros(len(t))
x[0] = x0
v[0] = v0
for i in range(len(t)-1):
dt = t[i + 1] - t[i]
x[i + 1] = x[i] + v[i]*dt
v[i + 1] = v0
return(x,v)

antwoord = "B"

x_an = analytisch(x0, v0, t)[0]

v_an = analytisch(x0, v0, t)[1]
x_num = numeriek(x0, v0, t) [0]
v_num = numeriek(x0, v0, t) [1]

fig, ax = plt.subplots(1, 2)
ax[0].plot(t, x_num, linestyle='--')
ax[0].plot(t, x_an)
ax[1].plot(t, x_num-x_an)

antwoord2 = "C"
1.2 Bewegen met constante versnelling
import numpy as np
import matplotlib.pyplot as plt
dt = 0.1
t0 = 0.0
t1 = 10.0
x0 = 0.0
v0 = 40.0
a0 = -9.81
t = np.linspace(0, 10, 101)

def analytisch(x0, v0, a0, t):

a = a0
v = v0 + a0*t
x = x0 + v0*t + 0.5*a0*(t**2)
return (x, v, a)

def numeriek(x0, v0, a0, t):

v = np.zeros(len(t))
x = np.zeros(len(t))
a = np.zeros(len(t))
v[0] = v0
x[0] = x0
a[0] = a0
for i in range(len(t) - 1):
dt = (t[i + 1] - t[i])
a[i + 1] = a0
v[i + 1] = v[i] + dt * a[i]
x[i + 1] = x[i] + v[i] * dt
a_num = a0
return (x, v, a)

x_an = analytisch(x0, v0, a0, t)[0]

v_an = analytisch(x0, v0, a0, t)[1]
a_an = analytisch(x0, v0, a0, t)[2]
x_num = numeriek(x0, v0, a0, t)[0]
v_num = numeriek(x0, v0, a0, t)[1]
a_num = numeriek(x0, v0, a0, t)[2]

fig, ax = plt.subplots(1, 2)
ax[0].plot(t, x_num, linestyle='--')
ax[0].plot(t, x_an)
ax[0].set_title('numeriek en analytisch bepaalde functie')
ax[1].plot(t, x_num-x_an)

antwoord = "B"
antwoord2 = "A"
1.3 Bewegen met variabele versnelling 1
#import modules#

#define variables#
dt = 0.1
t0 = 0.0
t1 = 10.0
x0 = 0.0
v0 = 0.0
m = 5.0
t = np.arange(0,10.1,dt)

#define function for acceleration#

def versnelling(t):
F = 0.7*np.sin(3*t)
a = F/m
return a#Dit doet niks in de code? voor een punt moet je per se
verunc = versnelling(t)

#define numeric function#

def numeriek(x0, v0,a_func, t):
x = np.zeros(len(t))
v = np.zeros(len(t))
a = np.zeros(len(t))

x[0]= x0
v[0]= v0
a[0]= (versnelling(t[0]))

for i in range(len(t)-1):
dt = t[i + 1] - t[i]
x[i+1] = x[i] + v[i]*dt
v[i+1] = v[i] + (versnelling(t[i]))*dt
a[i+1] = (versnelling(t[i+1]))
x,v,a
#versnelling(t) gebruiken ipv a_func)
a_f

#define analyti function#

def analytisch(x0,v0,t):
a = (versnelling(t))
v = 0.7/(3*m) - 0.7*np.cos(3*t)/(3*m) +v0
x = x0 + v0*t + 0.7*t/(3*m) - 0.7*np.sin(3*t)/(9*m)
 return x,v,a
print(a_func[2]) = print(versnelling(t[2]))
#Splffit results#
x_num = numeriek(x0,v0,a_func,t)[0]
v_num = numeriek(x0,v0,a_func,t)[1]
a_num = numeriek(x0,v0,a_func,t)[2]

x_an = analytisch(x0,v0,t)[0]
v_an = analytisch(x0,v0,t)[1]
a_an = analytisch(x0,v0,t)[2]

#multiple choice#
antwoord = "B"

numeriek en resultaten werkt niet volgens mij

bij mij ook niet

bij mij wel
wat heb je gedaan dan waardoor het werkt
 1.4 Bewegen met variabele versnelling 2
import numpy as np

x0 = 0
v0 = 4.5
m = 95

def versnelling(x):
if x < 2000:
F = 15.0
else:
F = -8.0
a = F/m
return a

t = np.linspace(0,300, 3001)

def numeriek(x0, v0, versnelling, t):

x = np.zeros(len(t))
v = np.zeros(len(t))
a = np.zeros(len(t))

x[0] = x0
v[0] = v0
a[0] = versnelling(x[0])
for i in range(len(t) - 1):
dt = t[i+1] - t[i]
x[i+1] = x[i] + v[i]*dt
v[i+1] = v[i] + a[i] * dt
a[i+1] = versnelling(x[i+1])
return x, v, a

x_num = numeriek(x0, v0, versnelling, t)[0]

v_num = numeriek(x0, v0, versnelling, t)[1]
a_num = numeriek(x0, v0, versnelling, t)[2]

v_3000_num = np.interp(3000, x_num, v_num)

t_3000_num = np.interp(3000, x_num, t)
v_3000_diff = np.absolute(v_3000_num - np.sqrt(8800/19 + 4.5**2))
print(v_3000_diff)
 1.5 Bewegen met variabele versnelling 3
import numpy as np
import matplotlib.pyplot as plt

x0 = 0
v0 = 14
m = 110000
F_prop = 0
dt = 0.1

t = np.arange(0, 20.1, dt)

def versnelling(v):
a = (F_prop - 120 * v**3) / m
return a

def numeriek(x0, v0, a_func, t):

x = np.zeros(len(t))
v = np.zeros(len(t))
a = np.zeros(len(t))
x[0] = x0
v[0] = v0
a[0] = (versnelling(v[0]))
for i in range(len(t)-1):
dt = t[i+1] - t[i]
x[i + 1] = x[i] + v[i] * dt
v[i + 1] = v[i] + a[i] * dt
a[i+1] = (versnelling(v[i+1]))
return x,v,a
x_num,v_num,a_num = numeriek(x0, v0, versnelling, t)
fig, ax = plt.subplots(1, 3)
ax[0].plot(t, x_num)
ax[1].plot(t, v_num)
ax[2].plot(t, a_num)
plt.show()

def analytisch(x0,v0,t):
x = (2*m/240)*np.sqrt((240*t/m)+1/(v0**2))-(2*m/(240*v0))+x0
v = 1/np.sqrt(240*t/m+1/v0**2)
a = -120*(1/np.sqrt(240*t/m+1/v0**2))**3/m
return x,v,a
x_an, v_an, a_an = analytisch(x0,v0,t)
t = np.arange(0,20.001,0.001)
x_num = numeriek(x0, v0, versnelling,t)[0]
x_verschil_15 = x_num[15000]-x_an[150]
 1.6 Bewegen in 2D
import numpy as np
import matplotlib.pyplot as plt
def versnelling(x, y, vx, vy):
ax = 0.0
ay = -9.81
return ax, ay

x0 = 0.0
y0 = 10.0
vx0 = 20.0
vy0 = 10.0
m = 0.5
t = np.linspace(0,3,301)

def versnelling(x, y, vx, vy):

Fwx = - k * vx
Fwy = - k * vy
ax = (Fwx/m)
ay = -9.81 + (Fwy/m)
return ax, ay

def numeriek(x0, y0, vx0, vy0, a_func, t):

x = np.zeros(len(t))
y = np.zeros(len(t))
vx = np.zeros(len(t))
vy = np.zeros(len(t))
ax = np.zeros(len(t))
ay = np.zeros(len(t))
k = 0.21

x[0] = x0
y[0] = y0
vy[0] = vy0
ax[0], ay[0] = a_func(x0, y0, vx0, vy0)

for i in range(len(t)-1):
dt = t[i + 1] - t[i]
x[i + 1] = x[i] + vx[i] * dt
y[i + 1] = y[i] + vy[i] * dt
vx[i + 1] = vx[i] + ax[i] * dt
vy[i + 1] = vy[i] + ay[i] * dt
ax[i + 1], ay[i + 1] = a_func(x[i + 1], y[i + 1], vx[i + 1], vy[i +
1])
 return(x,y,vx,vy,ax,ay) vx[0] = vx0

x_num, y_num, vx_num, vy_num, ax_num, ay_num = numeriek(x0, y0, vx0, vy0,
versnelling, t)

x0 = 0.0
y0 = 10.0

vx0 = 20.0
vy0 = 10.0
m = 0.5
t = np.linspace(0,3,301)
k = 0.21
x_num2 = numeriek(x0, y0, vx0, vy0, versnelling, t)[0]
y_num2 = numeriek(x0, y0, vx0, vy0, versnelling, t)[1]

#Gravitatie
 Tutorial 2

2.1 Massa-veer
m = 12 #kg
k = 100 #N/m
def afgeleiden(state, t):
y, v = state
a = -(k*y)/m
return v, a

def numeriek(state0, a_func, t):

y = np.zeros(len(t))
v = np.zeros(len(t))
a = np.zeros(len(t))
y[0],v[0]= state0
a[0]= (a_func(state0,t[0]))[1]
for i in range(len(t)-1):
dt = t[i + 1] - t[i]
y[i+1] = y[i] + v[i]*dt
v[i+1] = v[i] + a[i]*dt
a[i+1] = a_func((y[i+1],v[i+1]),t) [1]

return y, v, a

import sympy as sm

def test_vergelijkingen():
m, k, y, y0, v0, t = sm.symbols('m k y y0 v0 t')
y = sm.Function('y')(t)
ddy= -k*y/m

return sm.Eq(sm.diff(y, t, 2), ddy)

test_vergelijkingen()

t = np.linspace(0,10,10001)
y0 = 0.1
v0 = 1.0
state0 = [y0,v0]
y_num,v_num,a_num = numeriek(state0, afgeleiden, t)
y_an,v_an,a_an = analytisch(state0,t)
 t = np.linspace(0,10,10001)
y0 = 0.1
v0 = 1.0
state0 = [y0,v0]
y_num,v_num,a_num = numeriek(state0, afgeleiden, t)
y_an,v_an,a_an = analytisch(state0,t)

import numpy as np
import sympy as sm
import matplotlib.pyplot as plt

m = 12 #kg
k = 100 #N/m

def afgeleiden(state, t):

y, v = state
a = -(k*y)/m
return v, a

def numeriek(state0, a_func, t):

y = np.zeros(len(t))
v = np.zeros(len(t))
a = np.zeros(len(t))
y[0],v[0]= state0
a[0]= a_func(state0,t[0])[1]
for i in range(len(t)-1):
dt = t[i + 1] - t[i]
y[i+1] = y[i] + v[i]*dt
v[i+1] = v[i] + a[i]*dt
a[i+1] = a_func((y[i+1],v[i+1]),t)[1]

return y, v, a

def analytisch(state0, t):

y0, v0 = state0
w = np.sqrt(k/m)
A = v0/w
B = y0
y = A*np.sin(w*t) + B*np.cos(w*t)
v = A*w*np.cos(w*t) - B*w*np.sin(w*t)
a = -A*w**2*np.sin(w*t) - B*w**2*np.cos(w*t)
return y, v, a
fig, ax = plt.subplots(1, 2)
ax[0].plot(t, y_num)
ax[0].plot(t, y_an)
ax[0].set_title('numeriek en analytisch bepaalde functie')
ax[1].plot(t, y_num-y_an)
plt.show()

fig, ax = plt.subplots(1, 1)
ax.plot(t, y_num)
ax.set_xlabel('tijd [s]')
ax.set_ylabel('positie [m]')
ax.axhline(0, linestyle=':', color='k')
plt.show()

2.2 Massa veer met zwaartekracht

import numpy as np
import sympy as sp
'''Opdracht 1'''
m = 12.0
k = 100.0
g = 9.81
y0 = 0.1
v0 = 1
t = np.linspace(0,10,10001)
state0 = (y0,v0)
def afgeleiden(state, t):
y,v= state
a=g-(k * y) / m
return v, a

''Opdracht 2'''
def numeriek(state0, a_func, t):
y0,v0=state0
y=np.zeros(len(t))
 v=np.zeros(len(t))
a=np.zeros(len(t))
y[0]=y0
v[0]=v0
a[0]=a_func(state0,t[0])[1]

for i in range(len(t)-1):
dt = t[i + 1] - t[i]
v[i + 1]=v[i]+a[i]*dt
y[i + 1]=y[i]+v[i]*dt
a[i + 1]=a_func((y[i+1],v[i+1]),t[i+1])[1]
return y, v, a

'''Opdracht 3'''
m, k, g, y, y0, v0, t = sp.symbols('m k g y y0 v0 t')
y = sp.Function('y')(t)
ddy=(- k * y + m * g)/m

sp.Eq(sp.diff(y, t, 2), ddy)

'''Opdracht 4'''
y_p= m*g/k

'''Opdracht 5'''
omega = sp.sqrt(k/m)
A= v0/omega
B= y0 - g*m/k

'''Opdracht 6'''
k = 100
g = 9.81
m = 12
y_p = g*m/k

t = np.linspace(0,10,10001)

def analytisch(state0, t):

y0,v0=state0
w=np.sqrt(k/m)
A=v0/w
B=y0 - (g*m)/k
y=A*np.sin(w*t)+B*np.cos(w*t)+y_p
v=A*w*np.cos(w*t)-w*B*np.sin(w*t)
a=-A*(w**2)*np.sin(w*t)-B*(w**2)*np.cos(w*t)
return y, v, a
'''Opdracht 7'''
y_num, v_num, a_num = numeriek(state0, afgeleiden, t)
y_an, v_an, a_an = analytisch(state0, t)

'''Opdracht 8'''
import matplotlib.pyplot as plt
fig, ax = plt.subplots(1, 2)
ax[0].plot(t, y_num, linestyle='--')
ax[0].plot(t, y_an)
ax[0].set_title('numeriek en analytisch bepaalde functie')
ax[1].plot(t, y_num-y_an)

plt.show()

def E_totaal(y,v):
Ek = 0.5*m*v**2
Ev = 0.5*k*y**2
Eh = m*g*y
E = -Eh+Ev+Ek
return E
'''Opdracht 9'''

'''Opdracht 10'''
E_num = E_totaal(y_num,v_num)
E_an = E_totaal(y_an,v_an)
'''Opdracht 11'''
antwoord_num = 'C'
antwoord_an = 'B'
 2.3 Nieuwe integratiemethode / Odeint

from scipy.integrate import odeint

import matplotlib.pyplot as plt
import numpy as np

m = 12
k = 100
g = 9.81
y0 = 0.1
v0 = 1.0

t = np.arange(0, 10.001, 0.001)

def afgeleiden(state, t):

y = state[0]
v = state[1]
a = -(k * y) / m + g
return v, a

resultaat = odeint(afgeleiden, [y0, v0], t)

y_num, v_num = resultaat.T

‘B’

antwoord2 = [2, 3, 4, 5]
 2.4 Elastische botsing
import numpy as np
import matplotlib.pyplot as plt

""" Opdracht 1 """

import numpy as np
import matplotlib.pyplot as plt

m = 0.8
g = 9.81
y0 = 1.2
v0 = 0.1
t0 = 0
t1 = 1.0
dt = 0.001 # begin opdracht
m = 0.8
g = 9.81
k = 1000
y0 = 1.2
v0 = 0.1
t0 = 0
t1 = 1
dt = 0.001
state0 = y0, v0

def f_zwaartekracht():
m = 0.8
g = 9.81
F_g = -m*g
return F_g

def f_grond(y):
k = 1000
if y < 0:
return -k*y
else:
return 0

def f_totaal(state, t):

y, v = state
 F = f_zwaartekracht()
return F

def versnelling(state, t):

m = 0.8
a = f_totaal(state, t)/m
return a

def numeriek(state0, versnelling, t):

y = np.zeros(len(t))
v = np.zeros(len(t))
a = np.zeros(len(t))

y[0] = state0[0]
v[0] = state0[1]
a[0] = -g

for i in range(len(t) - 1):

dt = t[i + 1] - t[i]
y[i + 1] = v[i]*dt + y[i]
v[i + 1] = a[i]*dt + v[i]
a[i + 1] = versnelling((y[i + 1], v[i + 1]), t[i + 1])
return y, v, a

: 0.001
k = 1e5 #begin opdracht: 1000

t = np.linspace(t0, t1, int((t1 - t0) / dt ) + 1) #moet +1 zijn aan begin! Kreeg error bij
laatste opdracht dat array te kort was dus bij laatste opdracht veranderd naar +2

def f_zwaartekracht():
m = 0.8
g = 9.81
F_g = -m * g
return F_g

def f_grond(y):
k = 1000
F_grond = k * np.maximum(0, -y)
 return F_grond

def f_totaal(state, t):

y, v = state
F_g = f_zwaartekracht()
F_grond = f_grond(y)
F = F_g + F_grond
return F

def versnelling(state, t):

y, v = states
F = f_totaal(state, t)
a = F / m
return a

""" Opdracht 2 """

t = np.arange(t0, t1+dt, dt)

y_num, v_num, a_num = numeriek(state0, versnelling, t)[0], numeriek(state0, versnelling,

t)[1], numeriek(state0, versnelling, t)[2]
""" Opdracht 3 """
def f_grond(y):
k = 1000
if y < 0:
return -k*y
else:
return 0

def f_totaal(state, t):

y, v = state
F = f_zwaartekracht()+f_grond(state[0])
return F

def versnelling(state, t):

m = 0.8
a = f_totaal(state, t)/m
return a

def numeriek(state0, versnelling, t):

 y = np.zeros(len(t))
v = np.zeros(len(t))
a = np.zeros(len(t))

y[0] = state0[0]
v[0] = state0[1]
a[0] = a0

for i in range(len(t) - 1):

dt = t[i + 1] - t[i]
y[i + 1] = v[i]*dt + y[i]
v[i + 1] = a[i]*dt + v[i]
a[i + 1] = versnelling((y[i + 1], v[i + 1]), t[i + 1])
return y, v, a

y_num5, v_num5, a_num5 = numeriek(state0, versnelling, t)[0], numeriek(state0,

versnelling, t)[1], numeriek(state0, versnelling, t)[2]
fig,ax = plt.subplots(1, 3)
ax[0].plot(t, y_num5)
ax[1].plot(t, v_num5)
ax[2].plot(t, a_num5)

""" Opdracht 4 """

antwoord = 'B'

""" Opdracht 5 """

y_min= 0.14950201997365709
""" Opdracht 6 """

E_toegevoegd = 0.5*m*(v_num5[1000])**2 + m*g*y_num5[1000] - m*g*y_num5[0] -

0.5*m*(v_num5[0])**2
""" Opdracht 7 """
f_nieuw = np.vectorize(f_grond)
index = np.where(f_nieuw(y_num5) > 0)[0]
index = np.array([506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517,
518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532,
533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547,
548, 549, 550, 551, 552, 553, 554, 555, 556, 557 , 558, 559, 560, 561, 562,
563, 564, 565, 566, 567, 568, 569, 570, 571 , 572, 573, 574, 575, 576 ,577,
578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592,
593, 594, 595, 596, 597])

print(index)

index = np.where(f_grond(y_num) > 0)[0]

""" Opdracht 8 """
fig, ax = plt.subplots(1, 1)
ax.plot(t[index], f_nieuw(y_num5[index]), '-o')
ax.set_xlabel('Tijd (s)')
ax.set_ylabel('$F_{grond}$ (N)')
plt.show()

""" Opdracht 9 """

antwoord2 = 'D'

""" Opdracht 10 """

print(np.max(v_num5))
print(np.min(v_num5))
impulsverschil = 8.009645387433197
print(impulsverschil)
""" Opdracht 11 """
index2 = np.where(f_nieu w(y_num5) <= 0)[0]
impuls_zwaartekracht = -m*v_num5[505]
print(impuls_zwaartekracht)
impuls_zwaartekracht = 0.7165467932664598

""" Opdracht 12 """

""" Opdracht 12 """

impuls_grond = 8.723615459066432
""" Opdracht 13 """
antwoord3 = 'C'

""" Opdracht 14 """

dt = 0.00001

def f_zwaartekracht():
m = 0.8
g = 9.81
F_g = -m*g
return F_g

def f_grond(y):
k = 1000
if y < 0:
return -k*y
else:
return 0
def f_totaal(state, t):
y, v = state
F = f_zwaartekracht() + f_grond
return F

def versnelling(state, t):

m = 0.8
a = f_totaal(state, t)/m
return a

def numeriek(state0, versnelling, t):

y = np.zeros(len(t))
v = np.zeros(len(t))
a = np.zeros(len(t))

y[0] = state0[0]
v[0] = state0[1]
a[0] = -g

for i in range(len(t) - 1):

dt = t[i + 1] - t[i]
y[i + 1] = v[i]*dt + y[i]
v[i + 1] = a[i]*dt + v[i]
a[i + 1] = versnelling((y[i + 1], v[i + 1]), t[i + 1])
return y, v, a

""" Opdracht 15 """

y_num2, v_num2, a_num2 = numeriek(state0, versnelling, t)[0], numeriek(state0,
versnelling, t)[1], numeriek(state0, versnelling, t)[2]
y_min2 =-0.01384420
t_botsing2 = -0.5049196+0.51385
 2.5 Instantane botsing

import numpy as np
import matplotlib.pyplot as plt

#Opdracht 1

m = 0.8
g = -9.81 # m/s^2
y0 = 1.2 # m
v0 = 0.1 # m/s
t0 = 0.0 # s
t1 = 1.0 # s # bij Restitutiecoëfficiënt is dit 2.0 s
a0 = -9.81 # m/s^2
dt = 0.001
state0 = y0, v0

t = np.arange(t0, t1+dt, dt)

def f_zwaartekracht():
F_g = m*g
return F_g

def versnelling(state, t):

a = f_zwaartekracht()/m
return a

def numeriek(state0, versnelling, t):

y = np.zeros(len(t))
v = np.zeros(len(t))
a = np.zeros(len(t))
y[0] = state0[0]
v[0] = state0[1]
a[0] = 0

for i in range(len(t) - 1):

dt = t[i + 1] - t[i]
v[i + 1] = v[i] + a[i] * dt
y[i + 1] = y[i] + v[i] * dt
a[i + 1] = versnelling((y[i + 1], v[i + 1]), t[i + 1])
if y[i + 1] < 0:
y[i + 1] = 0
 return y, v, a # kg

y_num, v_num, a_num = numeriek(state0, versnelling, t)

E_toegevoegd = 0.5*m*v_num[1000]**2 + m*g*y_num[1000]- 0.5*m*v_num[0]**2 -

m*g*y_num[0] v[i+1] = -v[i+1]
#Opdracht 2

#Restitutiecoefficient

t0 = 0 #s
t1 = 2 #s
dt = 0.001 #s
e = 0.75
t = np.arange(t0, t1+dt, dt)

def numeriek(state0, a_func, t):

y = np.zeros(len(t))
v = np.zeros(len(t))
a = np.zeros(len(t))

y0, v0 = state0
y[0] = y0
v[0] = v0
a[0] = a_func([y0, v0], t[0])

for i in range(len(t) - 1):

dt = t[i + 1] - t[i]
y[i + 1] = y[i] + v[i] * dt
v[i + 1] = v[i] + a[i] * dt
a[i + 1] = versnelling([y[i + 1], v[i + 1]], t[i + 1])
if y[i +1] < 0:
y[i + 1] = 0
v[i + 1] = -e*v[i + 1]

return y, v, a

y_num2, v_num2, a_num2 = numeriek(state0, versnelling, t)

def stoot():
 L = m * v_num[506] - m * v_num[505]
return L

stoot = stoot()

fig, ax = plt.subplots(1,3)

ax[0].plot(t, y_num)
ax[1].plot(t, v_num)
ax[2].plot(t, a_num)
plt.show()

_____________________________________
Antwoord=[‘A’,’B’]

Deze werkt niet

Tutorial 3

w;3.1 Hovercraft 1
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint

m = 460 #[kg]
I = 240 #[kg*m^2]
F = 1100 #[N]

def moment(theta):
M = F * 0.6 * np.cos(theta)
return M

def afgeleiden(state, t):

x, y , theta, vx, vy, omega = state
ax = F / m
ay = 0
alpha = moment(theta) / I
return vx, vy, omega, ax, ay, alpha

t = np.arange(0, 10.1, 0.1 )

state0 = 0, 0, 0, 0, 0, 0
resultaat = odeint(afgeleiden,state0,t)
x_num, y_num, theta_num, vx, vy, omega = resultaat.T
 3.2 Hovercraft 2
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint

m = 460 #[kg]
I = 240 #[kg*m^2]
F = 1100 #[N]

def moment(theta):
M = F * 0.6
return M

def afgeleiden(state, t):

x, y , theta, vx, vy, omega = state
Fx = np.cos(theta) * F
Fy = np.sin(theta) * F
ax = Fx / m
ay = Fy / m
alpha = moment(theta) / I
return vx, vy, omega, ax, ay, alpha

t = np.arange(0, 10.1, 0.1 )

state0 = 0, 0, 0, 0, 0, 0
resultaat = odeint(afgeleiden,state0,t)
x_num, y_num, theta_num, vx, vy, omega = resultaat.T
 3.3 Schijf aan een Veer (werkt niet volledig)
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import matplotlib.patches as mpatches
#matplotlib notebook
from scipy.integrate import odeint

m = 15 #[kg]
r = 1.2 #[m]
g = -9.81 #[m/s^2]
k = 100 #[N/m]
l_0 = 4 #[m]
theta_0 = 0
x = 0
y = -4
M_0 = [-1.2,-4]
I = 1/2 * m * r ** 2

def Ftot(state):
x,y,theta,vx,vy,omega = state
Px = x + r * np.cos(theta)
Py = y + r * np.sin(theta)
afstand_P_Q = np.sqrt(Px ** 2 + Py ** 2)
uitrekking = afstand_P_Q - l_0
F_k = k * uitrekking
s = (np.sqrt(Px ** 2 + Py ** 2))
F_kx = -Px / s * F_k
F_ky = -Py / s * F_k
Fx = F_kx
Fy = m * g + F_ky
return np.array([Fx,Fy])

def Mtot(state):
x,y,theta,vx,vy,omega = state
Px = x + r * np.cos(theta)
Py = y + r * np.sin(theta)
afstand_P_Q = np.sqrt(Px ** 2 + Py ** 2)
uitrekking = afstand_P_Q - l_0
F_k = k * uitrekking
s = (np.sqrt(Px ** 2 + Py ** 2))
F_kx = Px / s * F_k
F_ky = -Py / s * F_k
M = F_kx * r * np.sin(theta) + F_ky * r * np.cos(theta)
return M
def afgeleiden(state, t):
x,y,theta,vx,vy,omega = state
ax = Ftot(state)[0] / m
ay = Ftot(state)[1] / m
alpha = Mtot(state) / I
return vx, vy, omega, ax, ay, alpha

t = np.linspace(0, 100, 1001)

state_0 = -1.2, -4.0, 0, 0, 0, 0
resultaat = odeint(afgeleiden, state_0, t)
x_num, y_num, theta_num, vx, vy, omega = resultaat.T
 Opdracht 4
Sportauto
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint

t = np.arange(0,25.1,0.1)
x0 = 0.0
v0 = 0.0
a0 = 0.0

def versnelling(t):
if t<10:
a = 0.5 * t
elif t>=10 and t<=25:
a = -2
return a

def numeriek(x0, v0, a0, t):

v = np.zeros(len(t))
x = np.zeros(len(t))
a = np.zeros(len(t))
v[0] = v0
x[0] = x0
a[0] = versnelling(t[0])
for i in range(len(t) - 1):
dt = (t[i + 1] - t[i])
a[i + 1] = versnelling(t[i+1])
v[i + 1] = v[i] + dt * a[i]
x[i + 1] = x[i] + v[i] * dt
return (x, v, a)
x_euler, v_euler, a_euler = numeriek(x0, v0, a0, t)

def versnelling2(state, t):

x, v = state
if t < 10:
a = 0.5 * t
elif t >= 10:
a = -2
return [v, a]
state0 = [x0, v0]
state = odeint(versnelling2, state0, t)
x_odeint = state[:, 0]
v_odeint = state[:, 1]

t_stop_euler = 22.4
t_stop_odeint = 22.5

#Dit werkt ook

def t_check(v):
i=0
while v[i]>=0:
i+=1
else:
return i

t_stop_euler=t[t_check(v_euler)]
t_stop_odeint=t[t_check(v_odeint)]

def numeriek(state0, a_func, t):

y = np.zeros(len(t))
v = np.zeros(len(t))
a = np.zeros(len(t))

y0, v0 = state0
y[0] = y0
v[0] = v0
a[0] = a_func([y0, v0], t[0])

for i in range(len(t) - 1):

dt = t[i + 1] - t[i]
y[i + 1] = y[i] + v[i] * dt
v[i + 1] = v[i] + a[i] * dt
a[i + 1] = versnelling([y[i + 1], v[i + 1]], t[i + 1])
if y[i +1] < 0:
y[i + 1] = 0
v[i + 1] = -e*v[i + 1]

return y, v, a
Blok valt op een veer 🙂
help lan
Help? :)

numerieke resultaten (2/2 kleine afwijking) hij klopt nu!!!

—------------------------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint

k=25000
m=40
g=9.81
x0=2
v0=-5
state0 = (x0,v0)

t0 = 0
t1 = 5
dt = 0.001
t = np.linspace(t0, t1, 1+ int(t1/dt))

def afgeleiden(state, t):

x,v=state
if x<-0:
a = -g-(k/m*(x-0.15))
else:
a = -g
return(v,a)

resultaat = odeint(afgeleiden, state0, t)

x_num, v_num = resultaat.T

fig, ax = plt.subplots(1, 2)

ax[0].plot(x_num, label='numeriek')
ax[0].set_xlabel('t')

ax[1].plot(v_num, label='numeriek')
ax[1].set_xlabel('t')
#plt.show()
—------------------------------------------------------------------------------------------
indrukking (2/2)
—------------------------------------------------------------------------------------------
indrukking = -x_num[0]
for i in range(len(x_num)-1):
if x_num[int(i+1)] < -indrukking:
indrukking = -x_num[i+1]
#print(x_num[i+1],indrukking)
—------------------------------------------------------------------------------------------
numerieke resultaten 2 (2/2 kleine afwijking) met deze code zal v_num wel werken!
—------------------------------------------------------------------------------------------
k=25000
m=40
g=9.81
c=500

x0=2
v0=-5
state0 = (x0,v0)

t0 = 0
t1 = 10
dt = 0.001
t = np.linspace(t0, t1, 1+ int(t1/dt))

def afgeleiden(state, t):

x,v=state
if x<0:
a = -g+(-k/m*(x-0.15)) +(-c*v/m)
else:
a = -g
return(v,a)

resultaat = odeint(afgeleiden, state0, t)

x_num, v_num = resultaat.T
x_num2, v_num2 = resultaat.T

fig, ax = plt.subplots(1, 2)

ax[0].plot(x_num, label='numeriek')
ax[0].set_xlabel('t')

ax[1].plot(v_num, label='numeriek')
ax[1].set_xlabel('t')
plt.show()

—------------------------------------------------------------------------------------------

x_eind (2/2)
—------------------------------------------------------------------------------------------
x_eind = np.average(x_num2[9000:10000])
—------------------------------------------------------------------------------------------
v_eind (2/2 kleine afwijking)met bovenste code werkt ie
—------------------------------------------------------------------------------------------
v_eind = np.average(np.abs(v_num2[9000:10000]))
—------------------------------------------------------------------------------------------
#

Massa-veer-demper
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint

m = 30
k = 15e3
c = 20

#Beginvoorwaarden
x0 = 0
v0 = 0
state0 = (x0, v0)

#Tijd
t1 = 15
dt = 0.01
t = np.arange(0, t1+dt, dt)

def afgeleiden(state, t):

x, v = state
a = (1/m)*(-2*k*(x-x0)-c*v+90*np.cos(6*t))
return v, a

resultaat = odeint(afgeleiden, state0, t)

x_num, v_num = resultaat.T

index = np.where( (t>=10) & (t<=15) )

gemiddelde_uitwijking = np.mean(x_num[index])
maximale_uitwijking = np.max(x_num[index])
print(gemiddelde_uitwijking)

def afgeleiden2(state, t):

x, v = state
omega = np.sqrt(2*k/m - c**2/(4*m**2))
a = (1/m)*(-2*k*(x2-x0)-c*v+90*np.cos(omega*t))
return v, a

resultaat2 = odeint(afgeleiden2, state0, t)

x_num2, v_num2 = resultaat2
Vliegtuig
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint

T_A = 40000
T_B = 20000
m = 200000
vx0 = -300/3.6
r = 8
k = 15
I = (m)*k**2
state0 = 0,0,0,vx0,0,0

def moment_G():
M = (T_A-T_B)*r
return M

def afgeleiden(state, t):

x, y , theta, vx, vy, omega = state
F = (T_A + T_B)
Fx = np.cos(theta) * (F)
 Fy = np.sin(theta) * (F)
ax = -Fx / (m)
ay = -Fy / (m)
alpha = moment_G() / I
return vx, vy, omega, ax, ay, alpha

t0 = 0
t1 = 10
dt = 0.1
t = np.linspace(t0, t1, 101)

resultaat = odeint(afgeleiden, state0, t)

x_num, y_num, theta_num, vx_num, vy_num, omega_num = resultaat.T

hoeksnelheid_5 = resultaat.T[5][50]