gaat in een centrifuge de tijd langzamer?

[wnvl1]

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.

[Xilvo]

Bovendien heeft zelfs Matlab exact hetzelfde probleem.

Ik vermoed dat ze beide dezelfde bewezen standaardmethodes gebruiken. Niemand zit steeds het wiel opnieuw uit te vinden.

[wnvl1]

Als je de meetkundige plaats zoekt van alle punten die dezelfde potentiaal hebben als de potentiaal op de noordpool, dan denk ik dat je komt op de groene lijnen.

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.

[Xilvo]

Als ik het goed begrijp liggen de twee binnenste groenen lijnen niet op een andere plaats op het aardoppervlak maar diep in de aarde?

[wnvl1]

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.

Het numerieke probleem moet ik op zich wel kunnen oplossen door

(-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.

[wnvl1]

Als ik het goed begrijp liggen de twee binnenste groenen lijnen niet op een andere plaats op het aardoppervlak maar diep in de aarde?

Halve aardstraal ongeveer ter hoogte van evenaar volgens onze berekening toen. Inzoverre die numeriek stabiel was.

[Xilvo]

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!

[wnvl1]

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.

[wnvl1]

Als ik de aarde 10 keer sneller laat draaien dan ze in werkelijkheid draait, maar ik houd wel alle massa geconcentreerd in het centrum, dan kom ik met jouw lijnsegment methode deze vorm uit. Duidelijk geen ellips.

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()

[wnvl1]

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.

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()

[wnvl1]

Aan 10 keer de normale rotatiesnelheid.

[Xilvo]

Ik heb er nog geen tijd voor gehad, maar heb je nu nog maar één potentiaal?

[wnvl1]

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.

[wnvl1]

Taylor benadering en origineel voor potentiaal verschil evenaar - noordpool geplot voor straal die door de evenaar loop. De Taylor benadering op zich is dus OK.

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

[wnvl1]

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