he2851/Masterprojekt
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Projekt aufgeräumt, gha1 getestet, Runge-Kutta angepasst (gha2_num sollte jetzt deutlich schneller sein)

Browse Source
This commit is contained in:
Hendrik Möllersmann
2026-01-09 17:49:49 +01:00
parent cf756e3d9a
commit 797afdfd6f
23 changed files with 832 additions and 868 deletions
Download Patch File Download Diff File Expand all files Collapse all files

300
GHA_triaxial/panou.py
View File

@@ -1,42 +1,61 @@
import numpy as np
from numpy import sin, cos, sqrt, arctan2
import ellipsoide
import Numerische_Integration.num_int_runge_kutta as rk
import runge_kutta as rk
import winkelumrechnungen as wu
import ausgaben as aus
import GHA.rk as ghark
from scipy.special import factorial as fact
from math import comb
import GHA_triaxial.numeric_examples_panou as nep
# Panou, Korakitits 2019
import GHA_triaxial.numeric_examples_panou as ne_panou
import GHA_triaxial.numeric_examples_karney as ne_karney
from ellipsoide import EllipsoidTriaxial
from typing import Callable
def gha1_num_old(ell: ellipsoide.EllipsoidTriaxial, point, alpha0, s, num):
phi, lamb, h = ell.cart2geod(point, "ligas3")
x, y, z = ell.geod2cart(phi, lamb, 0)
p, q = ell.p_q(x, y, z)
def pq_ell(ell: EllipsoidTriaxial, x: float, y: float, z: float) -> tuple[np.ndarray, np.ndarray]:
"""
Berechnung von p und q in elliptischen Koordinaten
Panou, Korakitits 2019
:param x: x
:param y: y
:param z: z
:return: p und q
"""
n = ell.func_n(x, y, z)
dxds0 = p[0] * sin(alpha0) + q[0] * cos(alpha0)
dyds0 = p[1] * sin(alpha0) + q[1] * cos(alpha0)
dzds0 = p[2] * sin(alpha0) + q[2] * cos(alpha0)
beta, lamb = ell.cart2ell(np.array([x, y, z]))
B = ell.Ex ** 2 * cos(beta) ** 2 + ell.Ee ** 2 * sin(beta) ** 2
L = ell.Ex ** 2 - ell.Ee ** 2 * cos(lamb) ** 2
h = lambda dxds, dyds, dzds: dxds**2 + 1/(1-ell.ee**2)*dyds**2 + 1/(1-ell.ex**2)*dzds**2
c1 = x ** 2 + y ** 2 + z ** 2 - (ell.ax ** 2 + ell.ay ** 2 + ell.b ** 2)
c0 = (ell.ax ** 2 * ell.ay ** 2 + ell.ax ** 2 * ell.b ** 2 + ell.ay ** 2 * ell.b ** 2 -
(ell.ay ** 2 + ell.b ** 2) * x ** 2 - (ell.ax ** 2 + ell.b ** 2) * y ** 2 - (
ell.ax ** 2 + ell.ay ** 2) * z ** 2)
t2 = (-c1 + sqrt(c1 ** 2 - 4 * c0)) / 2
f1 = lambda x, dxds, y, dyds, z, dzds: dxds
f2 = lambda x, dxds, y, dyds, z, dzds: -h(dxds, dyds, dzds) / ell.func_H(x, y, z) * x
f3 = lambda x, dxds, y, dyds, z, dzds: dyds
f4 = lambda x, dxds, y, dyds, z, dzds: -h(dxds, dyds, dzds) / ell.func_H(x, y, z) * y/(1-ell.ee**2)
f5 = lambda x, dxds, y, dyds, z, dzds: dzds
f6 = lambda x, dxds, y, dyds, z, dzds: -h(dxds, dyds, dzds) / ell.func_H(x, y, z) * z/(1-ell.ex**2)
F = ell.Ey ** 2 * cos(beta) ** 2 + ell.Ee ** 2 * sin(lamb) ** 2
p1 = -sqrt(L / (F * t2)) * ell.ax / ell.Ex * sqrt(B) * sin(lamb)
p2 = sqrt(L / (F * t2)) * ell.ay * cos(beta) * cos(lamb)
p3 = 1 / sqrt(F * t2) * (ell.b * ell.Ee ** 2) / (2 * ell.Ex) * sin(beta) * sin(2 * lamb)
p = np.array([p1, p2, p3])
q = np.array([n[1] * p[2] - n[2] * p[1],
n[2] * p[0] - n[0] * p[2],
n[0] * p[1] - n[1] * p[0]])
funktionswerte = rk.verfahren([f1, f2, f3, f4, f5, f6], [x, dxds0, y, dyds0, z, dzds0], s, num, fein=False)
P2 = funktionswerte[-1]
P2 = (P2[0], P2[2], P2[4])
return P2
return p, q
def buildODE(ell):
def ODE(v):
def buildODE(ell: EllipsoidTriaxial) -> Callable:
"""
Aufbau des DGL-Systems
:param ell: Ellipsoid
:return: DGL-System
"""
def ODE(s: float, v: np.ndarray) -> np.ndarray:
"""
DGL-System
:param s: unabhängige Variable
:param v: abhängige Variablen
:return: Ableitungen der abhängigen Variablen
"""
x, dxds, y, dyds, z, dzds = v
H = ell.func_H(x, y, z)
@@ -46,54 +65,78 @@ def buildODE(ell):
ddy = -(h/H)*y/(1-ell.ee**2)
ddz = -(h/H)*z/(1-ell.ex**2)
return [dxds, ddx, dyds, ddy, dzds, ddz]
return np.array([dxds, ddx, dyds, ddy, dzds, ddz])
return ODE
def gha1_num(ell, point, alpha0, s, num):
def gha1_num(ell: EllipsoidTriaxial, point: np.ndarray, alpha0: float, s: float, num: int) -> tuple[np.ndarray, float]:
"""
Panou, Korakitits 2019
:param ell:
:param point:
:param alpha0:
:param s:
:param num:
:return:
"""
phi, lam, _ = ell.cart2geod(point, "ligas3")
x0, y0, z0 = ell.geod2cart(phi, lam, 0)
p, q = ell.p_q(x0, y0, z0)
p, q = pq_ell(ell, x0, y0, z0)
dxds0 = p[0] * sin(alpha0) + q[0] * cos(alpha0)
dyds0 = p[1] * sin(alpha0) + q[1] * cos(alpha0)
dzds0 = p[2] * sin(alpha0) + q[2] * cos(alpha0)
v_init = [x0, dxds0, y0, dyds0, z0, dzds0]
v_init = np.array([x0, dxds0, y0, dyds0, z0, dzds0])
F = buildODE(ell)
ode = buildODE(ell)
werte = rk.rk_chat(F, v_init, s, num)
x1, _, y1, _, z1, _ = werte[-1]
_, werte = rk.rk4(ode, 0, v_init, s, num)
x1, dx1ds, y1, dy1ds, z1, dz1ds = werte[-1]
return x1, y1, z1, werte
p1, q1 = pq_ell(ell, x1, y1, z1)
sigma = np.array([dx1ds, dy1ds, dz1ds])
P = p1 @ sigma
Q = q1 @ sigma
alpha1 = arctan2(P, Q)
def checkLiouville(ell: ellipsoide.EllipsoidTriaxial, points):
constantValues = []
for point in points:
x = point[1]
dxds = point[2]
y = point[3]
dyds = point[4]
z = point[5]
dzds = point[6]
if alpha1 < 0:
alpha1 += 2 * np.pi
values = ell.p_q(x, y, z)
p = values["p"]
q = values["q"]
t1 = values["t1"]
t2 = values["t2"]
return np.array([x1, y1, z1]), alpha1
P = p[0]*dxds + p[1]*dyds + p[2]*dzds
Q = q[0]*dxds + q[1]*dyds + q[2]*dzds
alpha = arctan2(P, Q)
# ---------------------------------------------------------------------------------------------------------------------
c = ell.ay**2 - (t1 * sin(alpha)**2 + t2 * cos(alpha)**2)
constantValues.append(c)
pass
def pq_para(ell: EllipsoidTriaxial, x: float, y: float, z: float) -> tuple[np.ndarray, np.ndarray]:
"""
Berechnung von p und q in parametrischen Koordinaten
Panou, Korakitits 2020
:param x: x
:param y: y
:param z: z
:return: p und q
"""
n = ell.func_n(x, y, z)
u, v = ell.cart2para(np.array([x, y, z]))
# 41-47
G = sqrt(1 - ell.ex ** 2 * cos(u) ** 2 - ell.ee ** 2 * sin(u) ** 2 * sin(v) ** 2)
q = np.array([-1 / G * sin(u) * cos(v),
-1 / G * sqrt(1 - ell.ee ** 2) * sin(u) * sin(v),
1 / G * sqrt(1 - ell.ex ** 2) * cos(u)])
p = np.array([q[1] * n[2] - q[2] * n[1],
q[2] * n[0] - q[0] * n[2],
q[0] * n[1] - q[1] * n[0]])
def gha1_ana(ell: ellipsoide.EllipsoidTriaxial, point, alpha0, s, maxM):
t1 = np.dot(n, q)
t2 = np.dot(n, p)
t3 = np.dot(p, q)
if not (t1<1e-10 or t1>1-1e-10) and not (t2<1e-10 or t2>1-1e-10) and not (t3<1e-10 or t3>1-1e-10):
raise Exception("Fehler in den normierten Vektoren")
return p, q
def gha1_ana_step(ell: ellipsoide.EllipsoidTriaxial, point, alpha0, s, maxM):
"""
Panou, Korakitits 2020, 5ff.
:param ell:
@@ -104,44 +147,36 @@ def gha1_ana(ell: ellipsoide.EllipsoidTriaxial, point, alpha0, s, maxM):
:return:
"""
x, y, z = point
# S. 6
x_m = [x]
y_m = [y]
z_m = [z]
# erste Ableitungen (7-8)
H = x ** 2 + y ** 2 / (1 - ell.ee ** 2) ** 2 + z ** 2 / (1 - ell.ex ** 2) ** 2
sqrtH = sqrt(H)
n = np.array([x / sqrtH,
y / ((1-ell.ee**2) * sqrtH),
z / ((1-ell.ex**2) * sqrtH)])
u, v = ell.cart2para(np.array([x, y, z]))
G = sqrt(1 - ell.ex**2 * cos(u)**2 - ell.ee**2 * sin(u)**2 * sin(v)**2)
q = np.array([-1/G * sin(u) * cos(v),
-1/G * sqrt(1-ell.ee**2) * sin(u) * sin(v),
1/G * sqrt(1-ell.ex**2) * cos(u)])
p = np.array([q[1]*n[2] - q[2]*n[1],
q[2]*n[0] - q[0]*n[2],
q[0]*n[1] - q[1]*n[0]])
p, q = pq_para(ell, x, y, z)
# 48-50
x_m.append(p[0] * sin(alpha0) + q[0] * cos(alpha0))
y_m.append(p[1] * sin(alpha0) + q[1] * cos(alpha0))
z_m.append(p[2] * sin(alpha0) + q[2] * cos(alpha0))
# H Ableitungen (7)
H_ = lambda p: np.sum([comb(p, i) * (x_m[p - i] * x_m[i] +
1 / (1-ell.ee**2) ** 2 * y_m[p-i] * y_m[i] +
1 / (1-ell.ex**2) ** 2 * z_m[p-i] * z_m[i]) for i in range(0, p+1)])
# 34
H_ = lambda p: np.sum([comb(p, p - i) * (x_m[p - i] * x_m[i] +
1 / (1 - ell.ee ** 2) ** 2 * y_m[p - i] * y_m[i] +
1 / (1 - ell.ex ** 2) ** 2 * z_m[p - i] * z_m[i])
for i in range(0, p + 1)])
# h Ableitungen (7)
h_ = lambda q: np.sum([comb(q, j) * (x_m[q-j+1] * x_m[j+1] +
1 / (1 - ell.ee ** 2) * y_m[q-j+1] * y_m[j+1] +
1 / (1 - ell.ex ** 2) * z_m[q-j+1] * z_m[j+1]) for j in range(0, q+1)])
# 35
h_ = lambda q: np.sum([comb(q, q-j) * (x_m[q-j+1] * x_m[j+1] +
1 / (1 - ell.ee ** 2) * y_m[q-j+1] * y_m[j+1] +
1 / (1 - ell.ex ** 2) * z_m[q-j+1] * z_m[j+1])
for j in range(0, q+1)])
# h/H Ableitungen (6)
hH_ = lambda t: 1/H_(0) * (h_(t) - fact(t) *
np.sum([H_(t+1-l) / (fact(t+1-l) * fact(l-1)) * hH_t[l-1] for l in range(1, t+1)]))
# 31
hH_ = lambda t: 1/H_(0) * (h_(t) - np.sum([comb(t, l-1) * H_(t+1-l) * hH_t[l-1] for l in range(1, t+1)]))
# xm, ym, zm Ableitungen (6)
x_ = lambda m: -np.sum([comb(m-2, k) * hH_t[m-2-k] * x_m[k] for k in range(0, m-2+1)])
# 28-30
x_ = lambda m: - np.sum([comb(m-2, k) * hH_t[m-2-k] * x_m[k] for k in range(0, m-2+1)])
y_ = lambda m: -1 / (1-ell.ee**2) * np.sum([comb(m-2, k) * hH_t[m-2-k] * y_m[k] for k in range(0, m-2+1)])
z_ = lambda m: -1 / (1-ell.ex**2) * np.sum([comb(m-2, k) * hH_t[m-2-k] * z_m[k] for k in range(0, m-2+1)])
@@ -155,11 +190,14 @@ def gha1_ana(ell: ellipsoide.EllipsoidTriaxial, point, alpha0, s, maxM):
x_m.append(x_(m))
y_m.append(y_(m))
z_m.append(z_(m))
a_m.append(x_m[m] / fact(m))
b_m.append(y_m[m] / fact(m))
c_m.append(z_m[m] / fact(m))
fact_m = fact(m)
# am, bm, cm (6)
# 22-24
a_m.append(x_m[m] / fact_m)
b_m.append(y_m[m] / fact_m)
c_m.append(z_m[m] / fact_m)
# 19-21
x_s = 0
for a in reversed(a_m):
x_s = x_s * s + a
@@ -170,25 +208,89 @@ def gha1_ana(ell: ellipsoide.EllipsoidTriaxial, point, alpha0, s, maxM):
for c in reversed(c_m):
z_s = z_s * s + c
return x_s, y_s, z_s
pass
p_s, q_s = pq_para(ell, x_s, y_s, z_s)
# 57-59
dx_s = 0
for i, a in reversed(list(enumerate(a_m[1:], start=1))):
dx_s = dx_s * s + i * a
dy_s = 0
for i, b in reversed(list(enumerate(b_m[1:], start=1))):
dy_s = dy_s * s + i * b
dz_s = 0
for i, c in reversed(list(enumerate(c_m[1:], start=1))):
dz_s = dz_s * s + i * c
# 52-53
sigma = np.array([dx_s, dy_s, dz_s])
P = p_s @ sigma
Q = q_s @ sigma
# 51
alpha1 = arctan2(P, Q)
if alpha1 < 0:
alpha1 += 2 * np.pi
return np.array([x_s, y_s, z_s]), alpha1
def gha1_ana(ell: EllipsoidTriaxial, point: np.ndarray, alpha0: float, s: float, maxM: int, maxPartCircum: int = 4):
if s > np.pi / maxPartCircum * ell.ax:
s /= 2
point_step, alpha_step = gha1_ana(ell, point, alpha0, s, maxM, maxPartCircum)
point_end, alpha_end = gha1_ana(ell, point_step, alpha_step, s, maxM, maxPartCircum)
else:
point_end, alpha_end = gha1_ana_step(ell, point, alpha0, s, maxM)
_, _, h = ell.cart2geod(point_end, "ligas3")
if h > 1e-5:
raise Exception("Analyitsche Methode ist explodiert, Punkt liegt nicht mehr auf dem Ellpsoid")
return point_end, alpha_end
if __name__ == "__main__":
# ell = ellipsoide.EllipsoidTriaxial.init_name("Eitschberger1978")
ell = ellipsoide.EllipsoidTriaxial.init_name("BursaSima1980round")
# ellbi = ellipsoide.EllipsoidTriaxial.init_name("Bessel-biaxial")
re = ellipsoide.EllipsoidBiaxial.init_name("Bessel")
# Panou 2013, 7, Table 1, beta0=60°
beta0, lamb0, beta1, lamb1, c, alpha0, alpha1, s = nep.get_example(table=1, example=3)
P0 = ell.ell2cart(beta0, lamb0)
P1 = ell.ell2cart(beta1, lamb1)
diffs_panou = []
examples_panou = ne_panou.get_random_examples(5)
for example in examples_panou:
beta0, lamb0, beta1, lamb1, _, alpha0, alpha1, s = example
P0 = ell.ell2cart(beta0, lamb0)
# P1_num = gha1_num(ell, P0, alpha0, s, 1000)
P1_num = gha1_num(ell, P0, alpha0, s, 10000)
P1_ana = gha1_ana(ell, P0, alpha0, s, 30)
P1_num, alpha1_num = gha1_num(ell, P0, alpha0, s, 100)
beta1_num, lamb1_num = ell.cart2ell(P1_num)
P1_ana, alpha1_ana = gha1_ana(ell, P0, alpha0, s, 60)
beta1_ana, lamb1_ana = ell.cart2ell(P1_ana)
diffs_panou.append((abs(beta1-beta1_num), abs(lamb1-lamb1_num), abs(beta1-beta1_ana), abs(lamb1-lamb1_ana)))
diffs_panou = np.array(diffs_panou)
mask_360 = (diffs_panou > 359) & (diffs_panou < 361)
diffs_panou[mask_360] = np.abs(diffs_panou[mask_360] - 360)
print(diffs_panou)
beta, lamb = ellipsoide.EllipsoidTriaxial.cart2ell(ell, P1_num)
ell = ellipsoide.EllipsoidTriaxial.init_name("KarneyTest2024")
diffs_karney = []
examples_karney = ne_karney.get_examples((30499, 30500, 40500))
# examples_karney = ne_karney.get_random_examples(5)
for example in examples_karney:
beta0, lamb0, alpha0, beta1, lamb1, alpha1, s = example
P0 = ell.ell2cart(beta0, lamb0)
P1_num, alpha1_num = gha1_num(ell, P0, alpha0, s, 100)
beta1_num, lamb1_num = ell.cart2ell(P1_num)
try:
P1_ana, alpha1_ana = gha1_ana(ell, P0, alpha0, s, 40)
beta1_ana, lamb1_ana = ell.cart2ell(P1_ana)
except:
beta1_ana, lamb1_ana = np.inf, np.inf
diffs_karney.append((wu.rad2deg(abs(beta1-beta1_num)), wu.rad2deg(abs(lamb1-lamb1_num)), wu.rad2deg(abs(beta1-beta1_ana)), wu.rad2deg(abs(lamb1-lamb1_ana))))
diffs_karney = np.array(diffs_karney)
mask_360 = (diffs_karney > 359) & (diffs_karney < 361)
diffs_karney[mask_360] = np.abs(diffs_karney[mask_360] - 360)
print(diffs_karney)
pass