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

Algorithmen Test

Browse Source
This commit is contained in:
Hendrik Möllersmann
2026-01-17 18:51:47 +01:00
parent 505aee6de7
commit 07212dcc97
8 changed files with 457 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
GHA_triaxial/ES_gha2.py
View File

@@ -128,14 +128,14 @@ def gha2_ES(ell: EllipsoidTriaxial, P0: NDArray, Pk: NDArray, stepLenTarget: flo
P_prev = P_next
print('Maximale Schrittanzahl erreicht.')
P_all.append(P_end)
# P_all.append(P_end)
totalLen += Bogenlaenge(P_prev, P_end)
p0i = ell.point_onto_ellipsoid(P0 + 10 * (P_all[1] - P0) / np.linalg.norm(P_all[1] - P0))
p0i = ell.point_onto_ellipsoid(P0 + stepLenTarget/1000 * (P_all[1] - P0) / np.linalg.norm(P_all[1] - P0))
sigma0 = (p0i - P0) / np.linalg.norm(p0i - P0)
alpha0 = sigma2alpha(ell_ES, sigma0, P0)
p1i = ell.point_onto_ellipsoid(Pk - 10 * (Pk - P_all[-2]) / np.linalg.norm(Pk - P_all[-2]))
p1i = ell.point_onto_ellipsoid(Pk - stepLenTarget/1000 * (Pk - P_all[-2]) / np.linalg.norm(Pk - P_all[-2]))
sigma1 = (Pk - p1i) / np.linalg.norm(Pk - p1i)
alpha1 = sigma2alpha(ell_ES, sigma1, Pk)

23
GHA_triaxial/approx_gha1.py
View File

@@ -1,6 +1,6 @@
import numpy as np
from ellipsoide import EllipsoidTriaxial
from .panou import louville_constant, func_sigma_ell, gha1_ana
from GHA_triaxial.panou import louville_constant, func_sigma_ell, gha1_ana
import plotly.graph_objects as go
import winkelumrechnungen as wu
@@ -19,24 +19,31 @@ def gha1_approx(ell: EllipsoidTriaxial, p0: np.ndarray, alpha0: float, s: float,
points = [p0]
alphas = [alpha0]
s_curr = 0.0
while s_curr < s:
ds_step = min(ds, s - s_curr)
if ds_step < 1e-8:
break
p1 = points[-1]
alpha1 = alphas[-1]
sigma = func_sigma_ell(ell, p1, alpha1)
p2 = p1 + ds_step * sigma
p2 = ell.point_onto_ellipsoid(p2)
ds_step = np.linalg.norm(p2 - p1)
points.append(p2)
dalpha = 1e-6
l2 = louville_constant(ell, p2, alpha1)
dl_dalpha = (louville_constant(ell, p2, alpha1+dalpha) - l2) / dalpha
alpha2 = alpha1 + (l0 - l2) / dl_dalpha
points.append(p2)
alphas.append(alpha2)
ds_step = np.linalg.norm(p2 - p1)
s_curr += ds_step
if s_curr > 10000000:
pass
if all_points:
return points[-1], alphas[-1], np.array(points)
@@ -71,10 +78,10 @@ def show_points(points: NDArray, p0: NDArray, p1: NDArray):
if __name__ == '__main__':
ell = EllipsoidTriaxial.init_name("BursaSima1980round")
P0 = ell.para2cart(0, 0)
alpha0 = wu.deg2rad(90)
s = 1000000
P1_ana, alpha1_ana = gha1_ana(ell, P0, alpha0, s, maxM=60, maxPartCircum=32)
P1_app, alpha1_app, points = gha1_approx(ell, P0, alpha0, s, ds=5000, all_points=True)
P0 = ell.para2cart(0.2, 0.3)
alpha0 = wu.deg2rad(35)
s = 13000000
P1_app, alpha1_app, points = gha1_approx(ell, P0, alpha0, s, ds=10000, all_points=True)
P1_ana, alpha1_ana = gha1_ana(ell, P0, alpha0, s, maxM=60, maxPartCircum=16)
show_points(points, P0, P1_ana)
print(np.linalg.norm(P1_app - P1_ana))

120
GHA_triaxial/approx_gha1_2.py Normal file
View File

@@ -0,0 +1,120 @@
import numpy as np
from ellipsoide import EllipsoidTriaxial
from panou import louville_constant, func_sigma_ell, gha1_ana
import plotly.graph_objects as go
import winkelumrechnungen as wu
from numpy import sin, cos, arccos
def Bogenlaenge(P1: NDArray, P2: NDArray) -> float:
"""
Berechnung der mittleren Bogenlänge zwischen zwei kartesischen Punkten
:param P1: kartesische Koordinate Punkt 1
:param P2: kartesische Koordinate Punkt 2
:return: Bogenlänge s
"""
R1 = np.linalg.norm(P1)
R2 = np.linalg.norm(P2)
R = 0.5 * (R1 + R2)
if P1 @ P2 / (R1 * R2) > 1:
s = np.linalg.norm(P1 - P2)
else:
theta = arccos(P1 @ P2 / (R1 * R2))
s = float(R * theta)
return s
def gha1_approx2(ell: EllipsoidTriaxial, p0: np.ndarray, alpha0: float, s: float, ds: float, all_points: bool = False) -> Tuple[NDArray, float] | Tuple[NDArray, float, NDArray]:
"""
Berechung einer Näherungslösung der ersten Hauptaufgabe
:param ell: Ellipsoid
:param p0: Anfangspunkt
:param alpha0: Azimut im Anfangspunkt
:param s: Strecke bis zum Endpunkt
:param ds: Länge einzelner Streckenelemente
:param all_points: Ausgabe aller Punkte als Array?
:return: Endpunkt, Azimut im Endpunkt, optional alle Punkte
"""
l0 = louville_constant(ell, p0, alpha0)
points = [p0]
alphas = [alpha0]
s_curr = 0.0
while s_curr < s:
ds_target = min(ds, s - s_curr)
if ds_target < 1e-8:
break
p1 = points[-1]
alpha1 = alphas[-1]
alpha1_mid = alphas[-1]
p2 = points[-1]
alpha2 = alphas[-1]
i = 0
while i < 2:
i += 1
sigma = func_sigma_ell(ell, p1, alpha1_mid)
p2_new = p1 + ds_target * sigma
p2_new = ell.point_onto_ellipsoid(p2_new)
p2 = p2_new
j = 0
while j < 2:
j += 1
dalpha = 1e-6
l2 = louville_constant(ell, p2, alpha2)
dl_dalpha = (louville_constant(ell, p2, alpha2 + dalpha) - l2) / dalpha
alpha2_new = alpha2 + (l0 - l2) / dl_dalpha
alpha2 = alpha2_new
alpha1_mid = (alpha1 + alpha2) / 2
points.append(p2)
alphas.append(alpha2)
ds_actual = np.linalg.norm(p2 - p1)
s_curr += ds_actual
if s_curr > 10000000:
pass
if all_points:
return points[-1], alphas[-1], np.array(points)
else:
return points[-1], alphas[-1]
def show_points(points: NDArray, p0: NDArray, p1: NDArray):
"""
Anzeigen der Punkte
:param points: Array aller approximierten Punkte
:param p0: Startpunkt
:param p1: wahrer Endpunkt
"""
fig = go.Figure()
fig.add_scatter3d(x=points[:, 0], y=points[:, 1], z=points[:, 2],
mode='lines', line=dict(color="red", width=3), name="Approx")
fig.add_scatter3d(x=[p0[0]], y=[p0[1]], z=[p0[2]],
mode='markers', marker=dict(color="green"), name="P0")
fig.add_scatter3d(x=[p1[0]], y=[p1[1]], z=[p1[2]],
mode='markers', marker=dict(color="green"), name="P1")
fig.update_layout(
scene=dict(xaxis_title='X [km]',
yaxis_title='Y [km]',
zaxis_title='Z [km]',
aspectmode='data'),
title="CHAMP")
fig.show()
if __name__ == '__main__':
ell = EllipsoidTriaxial.init_name("BursaSima1980round")
P0 = ell.para2cart(0.2, 0.3)
alpha0 = wu.deg2rad(35)
s = 13000000
P1_app, alpha1_app, points = gha1_approx2(ell, P0, alpha0, s, ds=10000, all_points=True)
P1_ana, alpha1_ana = gha1_ana(ell, P0, alpha0, s, maxM=60, maxPartCircum=16)
show_points(points, P0, P1_ana)
print(np.linalg.norm(P1_app - P1_ana))

8
GHA_triaxial/approx_gha2.py
View File

@@ -9,7 +9,7 @@ from typing import Tuple
from utils import sigma2alpha
def gha2(ell: EllipsoidTriaxial, p0: NDArray, p1: NDArray, ds: float, all_points: bool = False) -> Tuple[float, float, float] | Tuple[float, float, float, NDArray]:
def gha2_approx(ell: EllipsoidTriaxial, p0: NDArray, p1: NDArray, ds: float, all_points: bool = False) -> Tuple[float, float, float] | Tuple[float, float, float, NDArray]:
"""
Numerische Approximation für die zweite Hauptaufgabe
:param ell: Ellipsoid
@@ -83,15 +83,15 @@ def show_points(points: NDArray, points_app: NDArray, p0: NDArray, p1: NDArray):
if __name__ == '__main__':
ell = EllipsoidTriaxial.init_name("KarneyTest2024")
ell = EllipsoidTriaxial.init_name("BursaSima1980round")
beta0, lamb0 = (0.2, 0.1)
P0 = ell.ell2cart(beta0, lamb0)
beta1, lamb1 = (0.7, 0.3)
P1 = ell.ell2cart(beta1, lamb1)
alpha0_app, alpha1_app, s_app, points = gha2(ell, P0, P1, ds=1e-4, all_points=True)
alpha0_app, alpha1_app, s_app, points = gha2_approx(ell, P0, P1, ds=1000, all_points=True)
print("done")
alpha0, alpha1, s, betas, lambs = gha2_num(ell, beta0, lamb0, beta1, lamb1, n=5000, all_points=True)
points_ana = []
for beta, lamb in zip(betas, lambs):

2
GHA_triaxial/numeric_examples_karney.py
View File

@@ -26,7 +26,7 @@ def get_random_examples(num: int, seed: int = None) -> List:
"""
if seed is not None:
random.seed(seed)
with open("Karney_2024_Testset.txt") as datei:
with open(r"C:\Users\moell\OneDrive\Desktop\Vorlesungen\Master-Projekt\Python_Masterprojekt\GHA_triaxial\Karney_2024_Testset.txt") as datei:
lines = datei.readlines()
examples = []
for i in range(num):

10
GHA_triaxial/panou.py
View File

@@ -245,7 +245,7 @@ def gha1_ana_step(ell: EllipsoidTriaxial, point: NDArray, alpha0: float, s: floa
return p1, alpha1
def gha1_ana(ell: EllipsoidTriaxial, point: NDArray, alpha0: float, s: float, maxM: int, maxPartCircum: int = 4) -> Tuple[NDArray, float]:
def gha1_ana(ell: EllipsoidTriaxial, point: NDArray, alpha0: float, s: float, maxM: int, maxPartCircum: int = 16) -> Tuple[NDArray, float]:
if s > np.pi / maxPartCircum * ell.ax:
s /= 2
point_step, alpha_step = gha1_ana(ell, point, alpha0, s, maxM, maxPartCircum)
@@ -286,7 +286,7 @@ def alpha_ell2para(ell: EllipsoidTriaxial, beta: float, lamb: float, alpha_ell:
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:
if np.linalg.norm(sigma_para - sigma_ell) > 1e-9:
raise Exception("Alpha Umrechnung fehlgeschlagen")
return u, v, alpha_para
@@ -335,7 +335,7 @@ if __name__ == "__main__":
# diffs_panou[mask_360] = np.abs(diffs_panou[mask_360] - 360)
# print(diffs_panou)
ell = ellipsoide.EllipsoidTriaxial.init_name("KarneyTest2024")
ell: EllipsoidTriaxial = ellipsoide.EllipsoidTriaxial.init_name("KarneyTest2024")
diffs_karney = []
# examples_karney = ne_karney.get_examples((30499, 30500, 40500))
examples_karney = ne_karney.get_random_examples(20)
@@ -343,12 +343,12 @@ 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, 10000)
beta1_num, lamb1_num = ell.cart2ell(P1_num)
try:
_, _, alpha0_para = alpha_ell2para(ell, beta0, lamb0, alpha0_ell)
P1_ana, alpha1_ana = gha1_ana(ell, P0, alpha0_para, s, 30, maxPartCircum=16)
P1_ana, alpha1_ana = gha1_ana(ell, P0, alpha0_para, s, 45, maxPartCircum=32)
beta1_ana, lamb1_ana = ell.cart2ell(P1_ana)
except:
beta1_ana, lamb1_ana = np.inf, np.inf