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

Näherungslösung GHA 2

Browse Source
This commit is contained in:
Hendrik Möllersmann
2026-01-11 16:05:15 +01:00
parent 4d5b6fcc3e
commit 6cc7245b0f
7 changed files with 260 additions and 235 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
GHA_triaxial/panou.py
View File

@@ -8,21 +8,22 @@ from math import comb
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
from typing import Callable, Tuple, List
from numpy.typing import NDArray
def pq_ell(ell: EllipsoidTriaxial, x: float, y: float, z: float) -> tuple[np.ndarray, np.ndarray]:
def pq_ell(ell: EllipsoidTriaxial, point: NDArray) -> Tuple[NDArray, NDArray]:
"""
Berechnung von p und q in elliptischen Koordinaten
Panou, Korakitits 2019
:param x: x
:param y: y
:param z: z
:param ell: Ellipsoid
:param point: Punkt
:return: p und q
"""
n = ell.func_n(x, y, z)
x, y, z = point
n = ell.func_n(point)
beta, lamb = ell.cart2ell(np.array([x, y, z]))
beta, lamb = ell.cart2ell(point)
B = ell.Ex ** 2 * cos(beta) ** 2 + ell.Ee ** 2 * sin(beta) ** 2
L = ell.Ex ** 2 - ell.Ee ** 2 * cos(lamb) ** 2
@@ -49,7 +50,7 @@ def buildODE(ell: EllipsoidTriaxial) -> Callable:
:param ell: Ellipsoid
:return: DGL-System
"""
def ODE(s: float, v: np.ndarray) -> np.ndarray:
def ODE(s: float, v: NDArray) -> NDArray:
"""
DGL-System
:param s: unabhängige Variable
@@ -58,7 +59,7 @@ def buildODE(ell: EllipsoidTriaxial) -> Callable:
"""
x, dxds, y, dyds, z, dzds = v
H = ell.func_H(x, y, z)
H = ell.func_H(np.array([x, y, z]))
h = dxds**2 + 1/(1-ell.ee**2)*dyds**2 + 1/(1-ell.ex**2)*dzds**2
ddx = -(h/H)*x
@@ -68,7 +69,7 @@ def buildODE(ell: EllipsoidTriaxial) -> Callable:
return np.array([dxds, ddx, dyds, ddy, dzds, ddz])
return ODE
def gha1_num(ell: EllipsoidTriaxial, point: np.ndarray, alpha0: float, s: float, num: int) -> tuple[np.ndarray, float, list]:
def gha1_num(ell: EllipsoidTriaxial, point: NDArray, alpha0: float, s: float, num: int, all_points: bool = False) -> Tuple[NDArray, float] | Tuple[NDArray, float, List]:
"""
Panou, Korakitits 2019
:param ell:
@@ -76,12 +77,14 @@ def gha1_num(ell: EllipsoidTriaxial, point: np.ndarray, alpha0: float, s: float,
:param alpha0:
:param s:
:param num:
:param all_points:
:return:
"""
phi, lam, _ = ell.cart2geod(point, "ligas3")
x0, y0, z0 = ell.geod2cart(phi, lam, 0)
p0 = ell.geod2cart(phi, lam, 0)
x0, y0, z0 = p0
p, q = pq_ell(ell, x0, y0, z0)
p, q = pq_ell(ell, p0)
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)
@@ -93,7 +96,9 @@ def gha1_num(ell: EllipsoidTriaxial, point: np.ndarray, alpha0: float, s: float,
_, werte = rk.rk4(ode, 0, v_init, s, num)
x1, dx1ds, y1, dy1ds, z1, dz1ds = werte[-1]
p1, q1 = pq_ell(ell, x1, y1, z1)
point1 = np.array([x1, y1, z1])
p1, q1 = pq_ell(ell, point1)
sigma = np.array([dx1ds, dy1ds, dz1ds])
P = float(p1 @ sigma)
Q = float(q1 @ sigma)
@@ -103,21 +108,23 @@ def gha1_num(ell: EllipsoidTriaxial, point: np.ndarray, alpha0: float, s: float,
if alpha1 < 0:
alpha1 += 2 * np.pi
return np.array([x1, y1, z1]), alpha1, werte
if all_points:
return point1, alpha1, werte
else:
return point1, alpha1
# ---------------------------------------------------------------------------------------------------------------------
def pq_para(ell: EllipsoidTriaxial, x: float, y: float, z: float) -> tuple[np.ndarray, np.ndarray]:
def pq_para(ell: EllipsoidTriaxial, point: NDArray) -> Tuple[NDArray, NDArray]:
"""
Berechnung von p und q in parametrischen Koordinaten
Panou, Korakitits 2020
:param x: x
:param y: y
:param z: z
:param ell: Ellipsoid
:param point: Punkt
:return: p und q
"""
n = ell.func_n(x, y, z)
u, v = ell.cart2para(np.array([x, y, z]))
n = ell.func_n(point)
u, v = ell.cart2para(point)
# 41-47
G = sqrt(1 - ell.ex ** 2 * cos(u) ** 2 - ell.ee ** 2 * sin(u) ** 2 * sin(v) ** 2)
@@ -131,12 +138,12 @@ def pq_para(ell: EllipsoidTriaxial, x: float, y: float, z: float) -> tuple[np.nd
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):
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):
def gha1_ana_step(ell: EllipsoidTriaxial, point: NDArray, alpha0: float, s: float, maxM: int) -> Tuple[NDArray, float]:
"""
Panou, Korakitits 2020, 5ff.
:param ell:
@@ -153,7 +160,7 @@ def gha1_ana_step(ell: ellipsoide.EllipsoidTriaxial, point, alpha0, s, maxM):
y_m = [y]
z_m = [z]
p, q = pq_para(ell, x, y, z)
p, q = pq_para(ell, point)
# 48-50
x_m.append(p[0] * sin(alpha0) + q[0] * cos(alpha0))
@@ -208,7 +215,8 @@ def gha1_ana_step(ell: ellipsoide.EllipsoidTriaxial, point, alpha0, s, maxM):
for c in reversed(c_m):
z_s = z_s * s + c
p_s, q_s = pq_para(ell, x_s, y_s, z_s)
p1 = np.array([x_s, y_s, z_s])
p_s, q_s = pq_para(ell, p1)
# 57-59
dx_s = 0
@@ -234,10 +242,10 @@ def gha1_ana_step(ell: ellipsoide.EllipsoidTriaxial, point, alpha0, s, maxM):
if alpha1 < 0:
alpha1 += 2 * np.pi
return np.array([x_s, y_s, z_s]), alpha1
return p1, alpha1
def gha1_ana(ell: EllipsoidTriaxial, point: np.ndarray, alpha0: float, s: float, maxM: int, maxPartCircum: int = 4) -> tuple[np.ndarray, float]:
def gha1_ana(ell: EllipsoidTriaxial, point: NDArray, alpha0: float, s: float, maxM: int, maxPartCircum: int = 4) -> Tuple[NDArray, float]:
if s > np.pi / maxPartCircum * ell.ax:
s /= 2
point_step, alpha_step = gha1_ana(ell, point, alpha0, s, maxM, maxPartCircum)
@@ -251,14 +259,14 @@ def gha1_ana(ell: EllipsoidTriaxial, point: np.ndarray, alpha0: float, s: float,
return point_end, alpha_end
def alpha_para2ell(ell: EllipsoidTriaxial, u: float, v: float, alpha_para: float) -> tuple[float, float, float]:
x, y, z = ell.para2cart(u, v)
def alpha_para2ell(ell: EllipsoidTriaxial, u: float, v: float, alpha_para: float) -> Tuple[float, float, float]:
point = ell.para2cart(u, v)
beta, lamb = ell.para2ell(u, v)
p_para, q_para = pq_para(ell, x, y, z)
p_para, q_para = pq_para(ell, point)
sigma_para = p_para * sin(alpha_para) + q_para * cos(alpha_para)
p_ell, q_ell = pq_ell(ell, x, y, z)
p_ell, q_ell = pq_ell(ell, point)
alpha_ell = arctan2(p_ell @ sigma_para, q_ell @ sigma_para)
sigma_ell = p_ell * sin(alpha_ell) + q_ell * cos(alpha_ell)
@@ -267,49 +275,42 @@ def alpha_para2ell(ell: EllipsoidTriaxial, u: float, v: float, alpha_para: float
return beta, lamb, alpha_ell
def alpha_ell2para(ell: EllipsoidTriaxial, beta: float, lamb: float, alpha_ell: float) -> tuple[float, float, float]:
x, y, z = ell.ell2cart(beta, lamb)
def alpha_ell2para(ell: EllipsoidTriaxial, beta: float, lamb: float, alpha_ell: float) -> Tuple[float, float, float]:
point = ell.ell2cart(beta, lamb)
u, v = ell.ell2para(beta, lamb)
p_ell, q_ell = pq_ell(ell, x, y, z)
p_ell, q_ell = pq_ell(ell, point)
sigma_ell = p_ell * sin(alpha_ell) + q_ell * cos(alpha_ell)
p_para, q_para = pq_para(ell, x, y, z)
p_para, q_para = pq_para(ell, point)
alpha_para = arctan2(p_para @ sigma_ell, q_para @ sigma_ell)
sigma_para = p_para * sin(alpha_para) + q_para * cos(alpha_para)
if np.linalg.norm(sigma_para - sigma_ell) > 1e-12:
raise Exception("Alpha Umrechnung fehlgeschlagen")
print("Alpha Umrechnung fehlgeschlagen:", np.linalg.norm(sigma_para - sigma_ell))
return u, v, alpha_para
def func_sigma_ell(ell, x, y, z, alpha):
p, q = pq_ell(ell, x, y, z)
def func_sigma_ell(ell: EllipsoidTriaxial, point: NDArray, alpha: float) -> NDArray:
p, q = pq_ell(ell, point)
sigma = p * sin(alpha) + q * cos(alpha)
return sigma
def func_sigma_para(ell, x, y, z, alpha):
p, q = pq_para(ell, x, y, z)
def func_sigma_para(ell: EllipsoidTriaxial, point: NDArray, alpha: float) -> NDArray:
p, q = pq_para(ell, point)
sigma = p * sin(alpha) + q * cos(alpha)
return sigma
def louville_constant(ell: EllipsoidTriaxial, p0: np.ndarray, alpha: float) -> float:
def louville_constant(ell: EllipsoidTriaxial, p0: NDArray, alpha: float) -> float:
beta, lamb = ell.cart2ell(p0)
l = ell.Ey**2 * cos(beta)**2 * sin(alpha)**2 - ell.Ee**2 * sin(lamb)**2 * cos(alpha)**2
# x, y, z = p0
# t1, t2 = ell.func_t12(x, y, z)
# l_cart = ell.ay**2 - (t1 * sin(alpha)**2 + t2 * cos(alpha)**2)
# if abs(l - l_cart) > 1e-12:
# # raise Exception("Louville constant fehlgeschlagen")
# print("Diff zwischen constant:", abs(l - l_cart))
return l
def louville_l2c(ell, l):
def louville_l2c(ell: EllipsoidTriaxial, l: float) -> float:
return sqrt((l + ell.Ee**2) / ell.Ex**2)
def louville_c2l(ell, c):
def louville_c2l(ell: EllipsoidTriaxial, c: float) -> float:
return ell.Ex**2 * c**2 - ell.Ee**2
@@ -322,7 +323,7 @@ if __name__ == "__main__":
# beta0, lamb0, beta1, lamb1, _, alpha0_ell, alpha1_ell, s = example
# P0 = ell.ell2cart(beta0, lamb0)
#
# P1_num, alpha1_num, _ = gha1_num(ell, P0, alpha0_ell, s, 100)
# P1_num, alpha1_num = gha1_num(ell, P0, alpha0_ell, s, 100)
# beta1_num, lamb1_num = ell.cart2ell(P1_num)
#
# _, _, alpha0_para = alpha_ell2para(ell, beta0, lamb0, alpha0_ell)
@@ -342,7 +343,7 @@ if __name__ == "__main__":
beta0, lamb0, alpha0_ell, beta1, lamb1, alpha1_ell, s = example
P0 = ell.ell2cart(beta0, lamb0)
P1_num, alpha1_num, _ = gha1_num(ell, P0, alpha0_ell, s, 5000)
P1_num, alpha1_num = gha1_num(ell, P0, alpha0_ell, s, 5000)
beta1_num, lamb1_num = ell.cart2ell(P1_num)
try:
@@ -357,5 +358,3 @@ if __name__ == "__main__":
mask_360 = (diffs_karney > 359) & (diffs_karney < 361)
diffs_karney[mask_360] = np.abs(diffs_karney[mask_360] - 360)
print(diffs_karney)
pass