Projekt aufgeräumt, gha1 getestet, Runge-Kutta angepasst (gha2_num sollte jetzt deutlich schneller sein)
This commit is contained in:
43
GHA_triaxial/numeric_examples_karney.py
Normal file
43
GHA_triaxial/numeric_examples_karney.py
Normal file
@@ -0,0 +1,43 @@
|
||||
import random
|
||||
import winkelumrechnungen as wu
|
||||
|
||||
def line2example(line):
|
||||
split = line.split()
|
||||
example = [float(value) for value in split[:7]]
|
||||
for i, value in enumerate(example):
|
||||
if i < 6:
|
||||
example[i] = wu.deg2rad(value)
|
||||
# example[i] = value
|
||||
return example
|
||||
|
||||
def get_random_examples(num):
|
||||
"""
|
||||
beta0, lamb0, alpha0, beta1, lamb1, alpha1, s12
|
||||
:param num:
|
||||
:return:
|
||||
"""
|
||||
random.seed(42)
|
||||
with open("Karney_2024_Testset.txt") as datei:
|
||||
lines = datei.readlines()
|
||||
examples = []
|
||||
for i in range(num):
|
||||
example = line2example(lines[random.randint(0, len(lines) - 1)])
|
||||
examples.append(example)
|
||||
return examples
|
||||
|
||||
def get_examples(l_i):
|
||||
"""
|
||||
beta0, lamb0, alpha0, beta1, lamb1, alpha1, s12
|
||||
:param num:
|
||||
:return:
|
||||
"""
|
||||
with open("Karney_2024_Testset.txt") as datei:
|
||||
lines = datei.readlines()
|
||||
examples = []
|
||||
for i in l_i:
|
||||
example = line2example(lines[i])
|
||||
examples.append(example)
|
||||
return examples
|
||||
|
||||
if __name__ == "__main__":
|
||||
get_random_examples(10)
|
||||
@@ -1,4 +1,5 @@
|
||||
import winkelumrechnungen as wu
|
||||
import random
|
||||
|
||||
table1 = [
|
||||
(wu.deg2rad(0), wu.deg2rad(0), wu.deg2rad(0), wu.deg2rad(90), 1.00000000000,
|
||||
@@ -105,7 +106,22 @@ def get_example(table, example):
|
||||
def get_tables():
|
||||
return tables
|
||||
|
||||
def get_random_examples(num):
|
||||
random.seed(42)
|
||||
examples = []
|
||||
for i in range(num):
|
||||
table = random.randint(1, 4)
|
||||
if table == 4:
|
||||
example = random.randint(1, 8)
|
||||
else:
|
||||
example = random.randint(1, 7)
|
||||
example = get_example(table, example)
|
||||
examples.append(example)
|
||||
return examples
|
||||
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
test = get_example(1, 4)
|
||||
# test = get_example(1, 4)
|
||||
examples = get_random_examples(5)
|
||||
pass
|
||||
|
||||
@@ -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
|
||||
@@ -1,7 +1,9 @@
|
||||
import numpy as np
|
||||
from ellipsoide import EllipsoidTriaxial
|
||||
import Numerische_Integration.num_int_runge_kutta as rk
|
||||
import ausgaben as aus
|
||||
import runge_kutta as rk
|
||||
import GHA_triaxial.numeric_examples_karney as ne_karney
|
||||
import GHA_triaxial.numeric_examples_panou as ne_panou
|
||||
import winkelumrechnungen as wu
|
||||
|
||||
# Panou 2013
|
||||
def gha2_num(ell: EllipsoidTriaxial, beta_1, lamb_1, beta_2, lamb_2, n=16000, epsilon=10**-12, iter_max=30):
|
||||
@@ -110,27 +112,45 @@ def gha2_num(ell: EllipsoidTriaxial, beta_1, lamb_1, beta_2, lamb_2, n=16000, ep
|
||||
q_33, q_22, q_11, q_00)
|
||||
|
||||
if lamb_1 != lamb_2:
|
||||
def functions():
|
||||
def f_beta(lamb, beta, beta_p, X3, X4):
|
||||
return beta_p
|
||||
# def functions():
|
||||
# def f_beta(lamb, beta, beta_p, X3, X4):
|
||||
# return beta_p
|
||||
#
|
||||
# def f_beta_p(lamb, beta, beta_p, X3, X4):
|
||||
# (BETA, LAMBDA, E, G,
|
||||
# p_3, p_2, p_1, p_0,
|
||||
# p_33, p_22, p_11, p_00) = p_coef(beta, lamb)
|
||||
# return p_3 * beta_p ** 3 + p_2 * beta_p ** 2 + p_1 * beta_p + p_0
|
||||
#
|
||||
# def f_X3(lamb, beta, beta_p, X3, X4):
|
||||
# return X4
|
||||
#
|
||||
# def f_X4(lamb, beta, beta_p, X3, X4):
|
||||
# (BETA, LAMBDA, E, G,
|
||||
# p_3, p_2, p_1, p_0,
|
||||
# p_33, p_22, p_11, p_00) = p_coef(beta, lamb)
|
||||
# return (p_33 * beta_p ** 3 + p_22 * beta_p ** 2 + p_11 * beta_p + p_00) * X3 + \
|
||||
# (3 * p_3 * beta_p ** 2 + 2 * p_2 * beta_p + p_1) * X4
|
||||
#
|
||||
# return [f_beta, f_beta_p, f_X3, f_X4]
|
||||
|
||||
def buildODElamb():
|
||||
def ODE(lamb, v):
|
||||
beta, beta_p, X3, X4 = v
|
||||
|
||||
def f_beta_p(lamb, beta, beta_p, X3, X4):
|
||||
(BETA, LAMBDA, E, G,
|
||||
p_3, p_2, p_1, p_0,
|
||||
p_33, p_22, p_11, p_00) = p_coef(beta, lamb)
|
||||
return p_3 * beta_p ** 3 + p_2 * beta_p ** 2 + p_1 * beta_p + p_0
|
||||
|
||||
def f_X3(lamb, beta, beta_p, X3, X4):
|
||||
return X4
|
||||
|
||||
def f_X4(lamb, beta, beta_p, X3, X4):
|
||||
(BETA, LAMBDA, E, G,
|
||||
p_3, p_2, p_1, p_0,
|
||||
p_33, p_22, p_11, p_00) = p_coef(beta, lamb)
|
||||
return (p_33 * beta_p ** 3 + p_22 * beta_p ** 2 + p_11 * beta_p + p_00) * X3 + \
|
||||
dbeta = beta_p
|
||||
dbeta_p = p_3 * beta_p ** 3 + p_2 * beta_p ** 2 + p_1 * beta_p + p_0
|
||||
dX3 = X4
|
||||
dX4 = (p_33 * beta_p ** 3 + p_22 * beta_p ** 2 + p_11 * beta_p + p_00) * X3 + \
|
||||
(3 * p_3 * beta_p ** 2 + 2 * p_2 * beta_p + p_1) * X4
|
||||
|
||||
return [f_beta, f_beta_p, f_X3, f_X4]
|
||||
return np.array([dbeta, dbeta_p, dX3, dX4])
|
||||
|
||||
return ODE
|
||||
|
||||
N = n
|
||||
|
||||
@@ -144,15 +164,20 @@ def gha2_num(ell: EllipsoidTriaxial, beta_1, lamb_1, beta_2, lamb_2, n=16000, ep
|
||||
converged = False
|
||||
iterations = 0
|
||||
|
||||
funcs = functions()
|
||||
# funcs = functions()
|
||||
ode_lamb = buildODElamb()
|
||||
|
||||
for i in range(iter_max):
|
||||
iterations = i + 1
|
||||
|
||||
startwerte = [lamb_1, beta_1, beta_0, 0.0, 1.0]
|
||||
# startwerte = [lamb_1, beta_1, beta_0, 0.0, 1.0]
|
||||
startwerte = np.array([beta_1, beta_0, 0.0, 1.0])
|
||||
|
||||
werte = rk.verfahren(funcs, startwerte, dlamb, N)
|
||||
lamb_end, beta_end, beta_p_end, X3_end, X4_end = werte[-1]
|
||||
# werte = rk.verfahren(funcs, startwerte, dlamb, N)
|
||||
lamb_list, werte = rk.rk4(ode_lamb, lamb_1, startwerte, dlamb, N, False)
|
||||
# lamb_end, beta_end, beta_p_end, X3_end, X4_end = werte[-1]
|
||||
lamb_end = lamb_list[-1]
|
||||
beta_end, beta_p_end, X3_end, X4_end = werte[-1]
|
||||
|
||||
d_beta_end_d_beta0 = X3_end
|
||||
delta = beta_end - beta_2
|
||||
@@ -174,16 +199,20 @@ def gha2_num(ell: EllipsoidTriaxial, beta_1, lamb_1, beta_2, lamb_2, n=16000, ep
|
||||
raise RuntimeError("konvergiert nicht.")
|
||||
|
||||
# Z
|
||||
werte = rk.verfahren(funcs, [lamb_1, beta_1, beta_0, 0.0, 1.0], dlamb, N)
|
||||
# werte = rk.verfahren(funcs, [lamb_1, beta_1, beta_0, 0.0, 1.0], dlamb, N, False)
|
||||
lamb_list, werte = rk.rk4(ode_lamb, lamb_1, np.array([beta_1, beta_0, 0.0, 1.0]), dlamb, N, False)
|
||||
|
||||
beta_arr = np.zeros(N + 1)
|
||||
lamb_arr = np.zeros(N + 1)
|
||||
# lamb_arr = np.zeros(N + 1)
|
||||
lamb_arr = np.array(lamb_list)
|
||||
beta_p_arr = np.zeros(N + 1)
|
||||
|
||||
for i, state in enumerate(werte):
|
||||
lamb_arr[i] = state[0]
|
||||
beta_arr[i] = state[1]
|
||||
beta_p_arr[i] = state[2]
|
||||
# lamb_arr[i] = state[0]
|
||||
# beta_arr[i] = state[1]
|
||||
# beta_p_arr[i] = state[2]
|
||||
beta_arr[i] = state[0]
|
||||
beta_p_arr[i] = state[1]
|
||||
|
||||
(_, _, E1, G1,
|
||||
*_) = BETA_LAMBDA(beta_arr[0], lamb_arr[0])
|
||||
@@ -230,37 +259,59 @@ def gha2_num(ell: EllipsoidTriaxial, beta_1, lamb_1, beta_2, lamb_2, n=16000, ep
|
||||
converged = False
|
||||
iterations = 0
|
||||
|
||||
def functions_beta():
|
||||
def g_lamb(beta, lamb, lamb_p, Y3, Y4):
|
||||
return lamb_p
|
||||
# def functions_beta():
|
||||
# def g_lamb(beta, lamb, lamb_p, Y3, Y4):
|
||||
# return lamb_p
|
||||
#
|
||||
# def g_lamb_p(beta, lamb, lamb_p, Y3, Y4):
|
||||
# (BETA, LAMBDA, E, G,
|
||||
# q_3, q_2, q_1, q_0,
|
||||
# q_33, q_22, q_11, q_00) = q_coef(beta, lamb)
|
||||
# return q_3 * lamb_p ** 3 + q_2 * lamb_p ** 2 + q_1 * lamb_p + q_0
|
||||
#
|
||||
# def g_Y3(beta, lamb, lamb_p, Y3, Y4):
|
||||
# return Y4
|
||||
#
|
||||
# def g_Y4(beta, lamb, lamb_p, Y3, Y4):
|
||||
# (BETA, LAMBDA, E, G,
|
||||
# q_3, q_2, q_1, q_0,
|
||||
# q_33, q_22, q_11, q_00) = q_coef(beta, lamb)
|
||||
# return (q_33 * lamb_p ** 3 + q_22 * lamb_p ** 2 + q_11 * lamb_p + q_00) * Y3 + \
|
||||
# (3 * q_3 * lamb_p ** 2 + 2 * q_2 * lamb_p + q_1) * Y4
|
||||
#
|
||||
# return [g_lamb, g_lamb_p, g_Y3, g_Y4]
|
||||
|
||||
def buildODEbeta():
|
||||
def ODE(beta, v):
|
||||
lamb, lamb_p, Y3, Y4 = v
|
||||
|
||||
def g_lamb_p(beta, lamb, lamb_p, Y3, Y4):
|
||||
(BETA, LAMBDA, E, G,
|
||||
q_3, q_2, q_1, q_0,
|
||||
q_33, q_22, q_11, q_00) = q_coef(beta, lamb)
|
||||
return q_3 * lamb_p ** 3 + q_2 * lamb_p ** 2 + q_1 * lamb_p + q_0
|
||||
|
||||
def g_Y3(beta, lamb, lamb_p, Y3, Y4):
|
||||
return Y4
|
||||
|
||||
def g_Y4(beta, lamb, lamb_p, Y3, Y4):
|
||||
(BETA, LAMBDA, E, G,
|
||||
q_3, q_2, q_1, q_0,
|
||||
q_33, q_22, q_11, q_00) = q_coef(beta, lamb)
|
||||
return (q_33 * lamb_p ** 3 + q_22 * lamb_p ** 2 + q_11 * lamb_p + q_00) * Y3 + \
|
||||
dlamb = lamb_p
|
||||
dlamb_p = q_3 * lamb_p ** 3 + q_2 * lamb_p ** 2 + q_1 * lamb_p + q_0
|
||||
dY3 = Y4
|
||||
dY4 = (q_33 * lamb_p ** 3 + q_22 * lamb_p ** 2 + q_11 * lamb_p + q_00) * Y3 + \
|
||||
(3 * q_3 * lamb_p ** 2 + 2 * q_2 * lamb_p + q_1) * Y4
|
||||
|
||||
return [g_lamb, g_lamb_p, g_Y3, g_Y4]
|
||||
return np.array([dlamb, dlamb_p, dY3, dY4])
|
||||
return ODE
|
||||
|
||||
funcs_beta = functions_beta()
|
||||
# funcs_beta = functions_beta()
|
||||
ode_beta = buildODEbeta()
|
||||
|
||||
for i in range(iter_max):
|
||||
iterations = i + 1
|
||||
|
||||
startwerte = [beta_1, lamb_1, lamb_0, 0.0, 1.0]
|
||||
startwerte = [lamb_1, lamb_0, 0.0, 1.0]
|
||||
|
||||
werte = rk.verfahren(funcs_beta, startwerte, dbeta, N)
|
||||
beta_end, lamb_end, lamb_p_end, Y3_end, Y4_end = werte[-1]
|
||||
# werte = rk.verfahren(funcs_beta, startwerte, dbeta, N, False)
|
||||
beta_list, werte = rk.rk4(ode_beta, beta_1, startwerte, dbeta, N, False)
|
||||
|
||||
beta_end = beta_list[-1]
|
||||
# beta_end, lamb_end, lamb_p_end, Y3_end, Y4_end = werte[-1]
|
||||
lamb_end, lamb_p_end, Y3_end, Y4_end = werte[-1]
|
||||
|
||||
d_lamb_end_d_lambda0 = Y3_end
|
||||
delta = lamb_end - lamb_2
|
||||
@@ -279,16 +330,20 @@ def gha2_num(ell: EllipsoidTriaxial, beta_1, lamb_1, beta_2, lamb_2, n=16000, ep
|
||||
|
||||
lamb_0 = lamb_0 - step
|
||||
|
||||
werte = rk.verfahren(funcs_beta, [beta_1, lamb_1, lamb_0, 0.0, 1.0], dbeta, N)
|
||||
# werte = rk.verfahren(funcs_beta, [beta_1, lamb_1, lamb_0, 0.0, 1.0], dbeta, N, False)
|
||||
beta_list, werte = rk.rk4(ode_beta, beta_1, np.array([lamb_1, lamb_0, 0.0, 1.0]), dbeta, N, False)
|
||||
|
||||
beta_arr = np.zeros(N + 1)
|
||||
# beta_arr = np.zeros(N + 1)
|
||||
beta_arr = np.array(beta_list)
|
||||
lamb_arr = np.zeros(N + 1)
|
||||
lambda_p_arr = np.zeros(N + 1)
|
||||
|
||||
for i, state in enumerate(werte):
|
||||
beta_arr[i] = state[0]
|
||||
lamb_arr[i] = state[1]
|
||||
lambda_p_arr[i] = state[2]
|
||||
# beta_arr[i] = state[0]
|
||||
# lamb_arr[i] = state[1]
|
||||
# lambda_p_arr[i] = state[2]
|
||||
lamb_arr[i] = state[0]
|
||||
lambda_p_arr[i] = state[1]
|
||||
|
||||
# Azimute
|
||||
(BETA1, LAMBDA1, E1, G1,
|
||||
@@ -318,22 +373,54 @@ def gha2_num(ell: EllipsoidTriaxial, beta_1, lamb_1, beta_2, lamb_2, n=16000, ep
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
ell = EllipsoidTriaxial.init_name("BursaSima1980round")
|
||||
# beta1 = np.deg2rad(75)
|
||||
# lamb1 = np.deg2rad(-90)
|
||||
# beta2 = np.deg2rad(75)
|
||||
# lamb2 = np.deg2rad(66)
|
||||
# a1, a2, s = gha2_num(ell, beta1, lamb1, beta2, lamb2)
|
||||
# print(aus.gms("a1", a1, 4))
|
||||
# print(aus.gms("a2", a2, 4))
|
||||
# ell = EllipsoidTriaxial.init_name("Fiction")
|
||||
# # beta1 = np.deg2rad(75)
|
||||
# # lamb1 = np.deg2rad(-90)
|
||||
# # beta2 = np.deg2rad(75)
|
||||
# # lamb2 = np.deg2rad(66)
|
||||
# # a1, a2, s = gha2_num(ell, beta1, lamb1, beta2, lamb2)
|
||||
# # print(aus.gms("a1", a1, 4))
|
||||
# # print(aus.gms("a2", a2, 4))
|
||||
# # print(s)
|
||||
# cart1 = ell.para2cart(0, 0)
|
||||
# cart2 = ell.para2cart(0.4, 1.4)
|
||||
# beta1, lamb1 = ell.cart2ell(cart1)
|
||||
# beta2, lamb2 = ell.cart2ell(cart2)
|
||||
#
|
||||
# a1, a2, s = gha2_num(ell, beta1, lamb1, beta2, lamb2, n=5000)
|
||||
# print(s)
|
||||
cart1 = ell.para2cart(0, 0)
|
||||
cart2 = ell.para2cart(0.4, 0.4)
|
||||
beta1, lamb1 = ell.cart2ell(cart1)
|
||||
beta2, lamb2 = ell.cart2ell(cart2)
|
||||
|
||||
a1, a2, s = gha2_num(ell, beta1, lamb1, beta2, lamb2, n=2500)
|
||||
print(s)
|
||||
|
||||
ell = EllipsoidTriaxial.init_name("BursaSima1980round")
|
||||
diffs_panou = []
|
||||
examples_panou = ne_panou.get_random_examples(4)
|
||||
for example in examples_panou:
|
||||
beta0, lamb0, beta1, lamb1, _, alpha0, alpha1, s = example
|
||||
P0 = ell.ell2cart(beta0, lamb0)
|
||||
try:
|
||||
alpha0_num, alpha1_num, s_num = gha2_num(ell, beta0, lamb0, beta1, lamb1, n=4000, iter_max=10)
|
||||
diffs_panou.append(
|
||||
(wu.rad2deg(abs(alpha0 - alpha0_num)), wu.rad2deg(abs(alpha1 - alpha1_num)), abs(s - s_num)))
|
||||
except:
|
||||
print(f"Fehler für {beta0}, {lamb0}, {beta1}, {lamb1}")
|
||||
diffs_panou = np.array(diffs_panou)
|
||||
print(diffs_panou)
|
||||
|
||||
ell = EllipsoidTriaxial.init_name("KarneyTest2024")
|
||||
diffs_karney = []
|
||||
# examples_karney = ne_karney.get_examples((30500, 40500))
|
||||
examples_karney = ne_karney.get_random_examples(2)
|
||||
for example in examples_karney:
|
||||
beta0, lamb0, alpha0, beta1, lamb1, alpha1, s = example
|
||||
|
||||
try:
|
||||
alpha0_num, alpha1_num, s_num = gha2_num(ell, beta0, lamb0, beta1, lamb1, n=4000, iter_max=10)
|
||||
diffs_karney.append((wu.rad2deg(abs(alpha0-alpha0_num)), wu.rad2deg(abs(alpha1-alpha1_num)), abs(s-s_num)))
|
||||
except:
|
||||
print(f"Fehler für {beta0}, {lamb0}, {beta1}, {lamb1}")
|
||||
diffs_karney = np.array(diffs_karney)
|
||||
print(diffs_karney)
|
||||
pass
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user