gaat in een centrifuge de tijd langzamer?
Moderator: physicalattraction
- Berichten: 2.439
Re: gaat in een centrifuge de tijd langzamer?
Nee, je begrijpt mij niet, denk ik. Ik probeer het straks te verduidelijken.
Ik heb ook nog nergens expliciete bevestiging gevonden dat het een ellips is.
Ik heb ook nog nergens expliciete bevestiging gevonden dat het een ellips is.
- Moderator
- Berichten: 10.083
- Berichten: 2.439
Re: gaat in een centrifuge de tijd langzamer?
Let op voor deze berekening hadden we de volledige massa van de roterende aarde in het centrum genomen. Voor een bepaalde hoek theta kom je dus op twee oplossingen. Python convergeert steeds naar de binnenste oplossing en niet naar de buitenste. De buitenste oplossing zou min of meer moeten corresponderen met de "echte" aarde. Dat is wat ik probeer te zeggen.
- Moderator
- Berichten: 10.083
Re: gaat in een centrifuge de tijd langzamer?
Als ik het goed begrijp liggen de twee binnenste groenen lijnen niet op een andere plaats op het aardoppervlak maar diep in de aarde?
- Berichten: 2.439
Re: gaat in een centrifuge de tijd langzamer?
Het numerieke probleem moet ik op zich wel kunnen oplossen doorwnvl1 schreef: ↑zo 03 jul 2022, 18:18 Echter ik slaag er niet in om noch met fsolve, noch met brentq python naar deze tweede oplossing te doen convergeren. Omdat je getallen van min of meer dezelfde grootte van elkaar aftrekt in de buurt van de werkelijke aardstraal ((-G * m / rp) - (((-G * m / r )) kan ik er wel inkomen dat het numeriek lastig is.
(-G * m / rp) - (((-G * m / r ) + ...
te schrijven als
(-G * m / rp) - (((-G * m / (rp + (r-rp) ) + ...
en dan een Taylorreeksontwikkeling te doen, dan moet het numerieke probleem van de baan zijn.
- Berichten: 2.439
- Moderator
- Berichten: 10.083
Re: gaat in een centrifuge de tijd langzamer?
Mooi, dan begrijp ik tenminste wat je bedoelt.
Die mogelijkheid gaat tegen m'n intuïtie in. Maar met intuïtie moet je heel voorzichtig zijn.
Ik ga er naar kijken!
Die mogelijkheid gaat tegen m'n intuïtie in. Maar met intuïtie moet je heel voorzichtig zijn.
Ik ga er naar kijken!
- Berichten: 2.439
Re: gaat in een centrifuge de tijd langzamer?
Die "halve" aardstraal als numerieke waarde is ook verwijderd van mijn intuïtie.
Het feit dat er "twee" ellipsen zijn is wel in lijn met mijn intuïtie.
Het feit dat er "twee" ellipsen zijn is wel in lijn met mijn intuïtie.
- Berichten: 2.439
Re: gaat in een centrifuge de tijd langzamer?
Code: Selecteer alles
import numpy as np
import scipy
from numpy import sin, cos
from scipy.optimize import fsolve
import matplotlib.pyplot as plt
from scipy.integrate import quad
rp = 6356752
re = 6378137
m = 5.97e24
G = 6.67e-11
w = 7.2722e-5 * 10
circle_x = [0]
circle_y = [rp]
ds = 10
rx = ds / 2
ry = rp
while rp ** 2 - rx ** 2 > 0:
rx += ds
ry = (rp ** 2 - rx ** 2) ** 0.5
circle_x.append(rx)
circle_y.append(ry)
linesegments_x = [0]
linesegments_y = [rp]
ds = 10
rx = ds / 2
ry = rp
r = np.sqrt(rx ** 2 + ry ** 2)
while ry > 0:
fz = G * m / r ** 2
fx = -fz * rx / r + w ** 2 * r
fy = -fz * ry / r
ftot = np.sqrt(fx ** 2 + fy ** 2)
rx += -ds * fy / ftot
ry += ds * fx / ftot
linesegments_x.append(rx)
linesegments_y.append(ry)
def func_arr(r):
return [(-G * m / rp) - (((-G * m / r[0]) - (r[0] * sin(theta) * w) ** 2) / 2)]
func_lambda = lambda r: (-G * m / rp) - (((-G * m / r ) - (r * sin(theta) * w) ** 2) / 2)
theta = 0
potential_x = []
potential_y = []
dtheta = 0.01
theta = dtheta / 2
while theta < (np.pi / 2):
print("Theta = %f" %theta)
theta += dtheta
# x = rx
# ry = fsolve(func_arr, rp)
#
# print("hallo")
# print("x="x)
# print(ry[0])
# print(func_lambda(ry[0]+1))
# print(func_lambda(10*rp))
r = fsolve(func_arr, [rp])
print("r = %f" %r)
print(func_lambda(4e6))
print(func_lambda(1e10))
r = scipy.optimize.brentq(func_lambda, 4e6, 1e10)
# print("r = %f" %r)
potential_x.append(r*sin(theta))
potential_y.append(r*cos(theta))
#plt.plot(potential_x, potential_y, label='potentiaal')
plt.plot(linesegments_x, linesegments_y, label='lijnsegment')
plt.plot(circle_x, circle_y, label='cirkel')
plt.legend()
plt.show()
# theta = np.pi/4
#
# a = np.linspace(0, 5*re, 1000)
# b = np.linspace(0, 0, 1000)
# c = np.linspace(0, 0, 1000)
#
# for i in range(len(a)-1):
# b[i] = func_lambda(a[i])
#
# plt.plot(a, b, color='red')
# plt.plot(a, c, color='green')
#
# plt.show()
- Berichten: 2.439
Re: gaat in een centrifuge de tijd langzamer?
De potentiaal methode (met Taylor benadering tot vierde orde) versus de lijnsegment methode aan 5 keer de normale rotatiesnelheid van de aarde (anders zie je niks)
De code is opgeruimd.
De code is opgeruimd.
Code: Selecteer alles
import numpy as np
import scipy
from numpy import sin, cos
from scipy.optimize import fsolve
import matplotlib.pyplot as plt
from scipy.integrate import quad
rp = 6356752
re = 6378137
m = 5.97e24
G = 6.67e-11
w = 7.2722e-5 * 5
circle_x = [0]
circle_y = [rp]
ds = 10
rx = ds / 2
ry = rp
while rp ** 2 - rx ** 2 > 0:
rx += ds
ry = (rp ** 2 - rx ** 2) ** 0.5
circle_x.append(rx)
circle_y.append(ry)
linesegments_x = [0]
linesegments_y = [rp]
ds = 10
rx = ds / 2
ry = rp
r = np.sqrt(rx ** 2 + ry ** 2)
while ry > 0:
fz = G * m / r ** 2
fx = -fz * rx / r + w ** 2 * r
fy = -fz * ry / r
ftot = np.sqrt(fx ** 2 + fy ** 2)
rx += -ds * fy / ftot
ry += ds * fx / ftot
linesegments_x.append(rx)
linesegments_y.append(ry)
def func_arr(r):
return [(-G * m / rp) - (((-G * m / r[0]) - (r[0] * sin(theta) * w) ** 2) / 2)]
def func_arr_taylor(r):
return [(G * m / rp) * (- (r[0] - rp) / rp + ((r[0] - rp) / rp) ** 2 - ((r[0] - rp) / rp) ** 3 + ((r[0] - rp) / rp) ** 4 ) + ((r[0] * sin(theta) * w) ** 2) / 2]
func_lambda = lambda r: (-G * m / rp) - (((-G * m / r ) - (r * sin(theta) * w) ** 2) / 2)
func_lambda_taylor = lambda r: (G * m / rp) * (- (r - rp) / rp + ((r - rp) / rp) **2 - ((r - rp) / rp) **3 + ((r - rp) / rp) **4 ) + ((r * sin(theta) * w) ** 2) / 2
theta = 0
potential_x = []
potential_y = []
dtheta = 0.01
theta = 0
while theta < (np.pi / 2):
print("Theta = %f" %theta)
r = fsolve(func_arr_taylor, [rp])
print("r = %f" %r)
potential_x.append(r*sin(theta))
potential_y.append(r*cos(theta))
theta += dtheta
plt.plot(potential_x, potential_y, label='potentiaal')
plt.plot(linesegments_x, linesegments_y, label='lijnsegment')
plt.plot(circle_x, circle_y, label='cirkel')
plt.legend()
plt.show()
- Berichten: 2.439
Re: gaat in een centrifuge de tijd langzamer?
Aan 10 keer de normale rotatiesnelheid.
- Moderator
- Berichten: 10.083
Re: gaat in een centrifuge de tijd langzamer?
Ik heb er nog geen tijd voor gehad, maar heb je nu nog maar één potentiaal?
- Berichten: 2.439
Re: gaat in een centrifuge de tijd langzamer?
Die twee oplossingen blijven bestaan volgens mij. Maar met deze benadering heeft het weinig nut om te kijken naar andere oplossingen. Mijn Taylor benadering is toch alleen maar geldig in de buurt van rp en erop gericht om een oplossing in die buurt te vinden.
- Berichten: 2.439
Re: gaat in een centrifuge de tijd langzamer?
Code: Selecteer alles
import numpy as np
import scipy
from numpy import sin, cos
from scipy.optimize import fsolve
import matplotlib.pyplot as plt
from scipy.integrate import quad
rp = 6356752
re = 6378137
m = 5.97e24
G = 6.67e-11
w = 7.2722e-5 * 10
circle_x = [0]
circle_y = [rp]
ds = 10
rx = ds / 2
ry = rp
while rp ** 2 - rx ** 2 > 0:
rx += ds
ry = (rp ** 2 - rx ** 2) ** 0.5
circle_x.append(rx)
circle_y.append(ry)
linesegments_x = [0]
linesegments_y = [rp]
ds = 10
rx = ds / 2
ry = rp
r = np.sqrt(rx ** 2 + ry ** 2)
while ry > 0:
fz = G * m / r ** 2
fx = -fz * rx / r + w ** 2 * r
fy = -fz * ry / r
ftot = np.sqrt(fx ** 2 + fy ** 2)
rx += -ds * fy / ftot
ry += ds * fx / ftot
linesegments_x.append(rx)
linesegments_y.append(ry)
def func_arr(r):
return [(-G * m / rp) + (G * m / r[0]) + (r[0] * sin(theta) * w) ** 2 / 2]
def func_arr_taylor(r):
return [(G * m / rp) * (- (r[0] - rp) / rp + ((r[0] - rp) / rp) ** 2 - ((r[0] - rp) / rp) ** 3 + ((r[0] - rp) / rp) ** 4 ) + ((r[0] * sin(theta) * w) ** 2) / 2]
func_lambda = lambda r: (-G * m / rp) + (G * m / r ) + (r * sin(theta) * w) ** 2 / 2
func_lambda_taylor = lambda r: ((G * m / rp) * (- (r - rp) / rp + ((r - rp) / rp) **2 - ((r - rp) / rp) **3 + ((r - rp) / rp) **4 )) + ((r * sin(theta) * w) ** 2) / 2
func_lambda1 = lambda r: (-G * m / rp) - (-G * m / r )
func_lambda1_taylor = lambda r: (G * m / rp) * (- (r - rp) / rp + ((r - rp) / rp) **2 - ((r - rp) / rp) **3 + ((r - rp) / rp) **4 )
theta = 0
potential_x = []
potential_y = []
dtheta = 0.01
theta = 0
while theta < (np.pi / 2):
print("Theta = %f" %theta)
r = fsolve(func_arr_taylor, [rp])
print("r = %f" %r)
potential_x.append(r*sin(theta))
potential_y.append(r*cos(theta))
theta += dtheta
plt.plot(potential_x, potential_y, label='potentiaal')
plt.plot(linesegments_x, linesegments_y, label='lijnsegment')
plt.plot(circle_x, circle_y, label='cirkel')
plt.legend()
plt.show()
x = np.linspace(0.5*rp,1.5*rp,1000) # 100 linearly spaced numbers
y = func_lambda_taylor(x) # computing the values of sin(x)/x
z = func_lambda(x) # computing the values of sin(x)/x
theta = np.pi/2
# compose plot
plt.plot(x,y) # sin(x)/x
plt.plot(x,z) # sin(x)/x
plt.show() # show the plot
- Berichten: 2.439
Re: gaat in een centrifuge de tijd langzamer?
Ook nog eens veldlijnen op dezelfde figuur gezet.
Code: Selecteer alles
import numpy as np
import scipy
from numpy import sin, cos
from scipy.optimize import fsolve
import matplotlib.pyplot as plt
from scipy.integrate import quad
rp = 6356752
re = 6378137
m = 5.97e24
G = 6.67e-11
w = 7.2722e-5 * 10
circle_x = [0]
circle_y = [rp]
ds = 10
rx = ds / 2
ry = rp
while rp ** 2 - rx ** 2 > 0:
rx += ds
ry = (rp ** 2 - rx ** 2) ** 0.5
circle_x.append(rx)
circle_y.append(ry)
linesegments_x = [0]
linesegments_y = [rp]
ds = 10
rx = ds / 2
ry = rp
r = np.sqrt(rx ** 2 + ry ** 2)
while ry > 0:
fz = G * m / r ** 2
fx = -fz * rx / r + w ** 2 * r
fy = -fz * ry / r
ftot = np.sqrt(fx ** 2 + fy ** 2)
rx += -ds * fy / ftot
ry += ds * fx / ftot
linesegments_x.append(rx)
linesegments_y.append(ry)
def func_arr(r):
return [(-G * m / rp) + (G * m / r[0]) + (r[0] * sin(theta) * w) ** 2 / 2]
def func_arr_taylor(r):
return [(G * m / rp) * (
- (r[0] - rp) / rp + ((r[0] - rp) / rp) ** 2 - ((r[0] - rp) / rp) ** 3 + ((r[0] - rp) / rp) ** 4) + (
(r[0] * sin(theta) * w) ** 2) / 2]
func_lambda = lambda r: (-G * m / rp) + (G * m / r) + (r * sin(theta) * w) ** 2 / 2
func_lambda_taylor = lambda r: ((G * m / rp) * (
- (r - rp) / rp + ((r - rp) / rp) ** 2 - ((r - rp) / rp) ** 3 + ((r - rp) / rp) ** 4)) + (
(r * sin(theta) * w) ** 2) / 2
func_lambda1 = lambda r: (-G * m / rp) - (-G * m / r)
func_lambda1_taylor = lambda r: (G * m / rp) * (
- (r - rp) / rp + ((r - rp) / rp) ** 2 - ((r - rp) / rp) ** 3 + ((r - rp) / rp) ** 4)
theta = 0
potential_x = []
potential_y = []
dtheta = 0.01
theta = 0
while theta < (np.pi / 2):
print("Theta = %f" % theta)
r = fsolve(func_arr_taylor, [rp])
print("r = %f" % r)
potential_x.append(r * sin(theta))
potential_y.append(r * cos(theta))
theta += dtheta
plt.plot(potential_x, potential_y, label='potentiaal')
plt.plot(linesegments_x, linesegments_y, label='lijnsegment')
plt.plot(circle_x, circle_y, label='cirkel')
plt.legend()
x, y = np.meshgrid(np.linspace(0.5*rp, 2*rp, 15), np.linspace(0, 2*rp, 15))
u = -G * m / (x**2 + y**2)** 1.5 * x + w ** 2 * (x**2 + y**2)** 0.5
v = -G * m / (x**2 + y**2)** 1.5 * y
q = plt.quiver(x, y, u, v)
plt.show()
x = np.linspace(0.5 * rp, 1.5 * rp, 1000) # 100 linearly spaced numbers
y = func_lambda_taylor(x) # computing the values of sin(x)/x
z = func_lambda(x) # computing the values of sin(x)/x
theta = np.pi / 2
# compose plot
plt.plot(x, y) # sin(x)/x
plt.plot(x, z) # sin(x)/x
plt.show() # show the plot