Abgabe fertig

nicht abgeben/GHA_biaxial/bessel.py

@@ -0,0 +1,36 @@
+from typing import Tuple
+
+import scipy as sp
+from ellipsoid_biaxial import EllipsoidBiaxial
+from numpy import *
+
+
+def gha1(re: EllipsoidBiaxial, phi0: float, lamb0: float, alpha0:float, s: float) -> Tuple[float, float, float]:
+    """
+    Berechnung der 1.GHA auf einem Rotationsellipsoid nach Bessel
+    :param re:
+    :param phi0:
+    :param lamb0:
+    :param alpha0:
+    :param s:
+    :return:
+    """
+    psi0 = re.phi2psi(phi0)
+    clairant = arcsin(cos(psi0) * sin(alpha0))
+    sigma0 = arcsin(sin(psi0) / cos(clairant))
+
+    sqrt_sigma = lambda sigma: sqrt(1 + re.e_ ** 2 * cos(clairant) ** 2 * sin(sigma) ** 2)
+    int_sqrt_sigma = lambda sigma: sp.integrate.quad(sqrt_sigma, sigma0, sigma)[0]
+
+    f_sigma1_i = lambda sigma1_i: (int_sqrt_sigma(sigma1_i) - s / re.b)
+
+    sigma1_0 = sigma0 + s / re.a
+    sigma1 = sp.optimize.newton(f_sigma1_i, sigma1_0)
+    psi1 = arcsin(cos(clairant) * sin(sigma1))
+    phi1 = re.psi2phi(psi1)
+    alpha1 = arcsin(sin(clairant) / cos(psi1))
+
+    f_d_lambda = lambda sigma: sin(clairant) * sqrt_sigma(sigma) / (1 - cos(clairant) ** 2 * sin(sigma) ** 2)
+    d_lambda = sqrt(1-re.e**2) * sp.integrate.quad(f_d_lambda, sigma0, sigma1)[0]
+    lamb1 = lamb0 + d_lambda
+    return phi1, lamb1, alpha1

nicht abgeben/GHA_biaxial/gauss.py

@@ -0,0 +1,101 @@
+from typing import Tuple
+
+from ellipsoid_biaxial import EllipsoidBiaxial
+from numpy import arctan, cos, sin, sqrt, tan
+
+
+def gha1(re: EllipsoidBiaxial, phi0: float, lamb0: float, alpha0: float, s: float, eps: float = 1e-12) -> Tuple[float, float, float]:
+    """
+    Berechnung der 1. Geodätische Hauptaufgabe nach Gauß´schen Mittelbreitenformeln
+    :param re: Klasse Ellipsoid
+    :param phi0: Breite Punkt 0
+    :param lamb0: Länge Punkt 0
+    :param alpha0: Azimut der geodätischen Linie in Punkt 1
+    :param s: Strecke zu Punkt 1
+    :param eps: Abbruchkriterium für Winkelgrößen
+    :return: Breite, Länge, Azimut von Punkt 21
+    """
+    t = lambda phi: tan(phi)
+    eta = lambda phi: sqrt(re.e_ ** 2 * cos(phi) ** 2)
+
+    F1 = lambda alpha, phi, s: 1 + (2 + 3 * t(phi) ** 2 + 2 * eta(phi) ** 2) / (24 * re.N(phi) ** 2) * sin(alpha) ** 2 * s ** 2 \
+                               + (t(phi)**2 - 1) * eta(phi) ** 2 / (8 * re.N(phi) ** 2) * cos(alpha) ** 2 * s ** 2
+
+    F2 = lambda alpha, phi, s: 1 + t(phi) ** 2 / (24 * re.N(phi) ** 2) * sin(alpha) ** 2 * s ** 2 \
+                               - (1 + eta(phi)**2 - 9 * eta(phi)**2 * t(phi)**2) / (24 * re.N(phi) ** 2) * cos(alpha) ** 2 * s ** 2
+
+    F3 = lambda alpha, phi, s: 1 + (1 + eta(phi) ** 2) / (12 * re.N(phi) ** 2) * sin(alpha) ** 2 * s ** 2 \
+                               + (3 + 8 * eta(phi)**2) / (24 * re.N(phi) ** 2) * cos(alpha) ** 2 * s ** 2
+
+    phi1_i = lambda alpha, phi: phi0 + cos(alpha) / re.M(phi) * s * F1(alpha, phi, s)
+    lamb1_i = lambda alpha, phi: lamb0 + sin(alpha) / (re.N(phi) * cos(phi)) * s * F2(alpha, phi, s)
+    alpha1_i = lambda alpha, phi: alpha0 + sin(alpha) * tan(phi) / re.N(phi) * s * F3(alpha, phi, s)
+
+    phi_m_i = lambda phi1: (phi0 + phi1) / 2
+    alpha_m_i = lambda alpha1: (alpha0 + alpha1) / 2
+
+    phi_m = []
+    alpha_m = []
+    phi1 = []
+    lamb1 = []
+    alpha1 = []
+
+    # 1. Näherung für P1
+    phi1.append(phi0 + cos(alpha0) / re.M(phi0) * s)
+    lamb1.append(lamb0 + sin(alpha0) / (re.N(phi0) * cos(phi0)) * s)
+    alpha1.append(alpha0 + sin(alpha0) * tan(phi0) / re.N(phi0) * s)
+
+    while True:
+        # Berechnug P_m durch Mittelbildung
+        phi_m.append(phi_m_i(phi1[-1]))
+        alpha_m.append(alpha_m_i(alpha1[-1]))
+        # Berechnung P1
+        phi1.append(phi1_i(alpha_m[-1], phi_m[-1]))
+        lamb1.append(lamb1_i(alpha_m[-1], phi_m[-1]))
+        alpha1.append(alpha1_i(alpha_m[-1], phi_m[-1]))
+
+        # Abbruchkriterium
+        if abs(phi1[-2] - phi1[-1]) < eps and \
+           abs(lamb1[-2] - lamb1[-1]) < eps and \
+           abs(alpha1[-2] - alpha1[-1]) < eps:
+            break
+    return phi1[-1], lamb1[-1], alpha1[-1]
+
+
+def gha2(re: EllipsoidBiaxial, phi0: float, lamb0: float, phi1: float, lamb1: float):
+    """
+    Berechnung der 2. Geodätische Hauptaufgabe nach Gauß´schen Mittelbreitenformeln
+    :param re: Klasse Ellipsoid
+    :param phi0: Breite Punkt 1
+    :param lamb0: Länge Punkt 1
+    :param phi1: Breite Punkt 2
+    :param lamb1: Länge Punkt 2
+    :return: Länge der geodätischen Linie, Azimut von P1 nach P2, Azimut von P2 nach P1
+    """
+
+    t = lambda phi: tan(phi)
+    eta = lambda phi: sqrt(re.e_ ** 2 * cos(phi) ** 2)
+
+    phi_0 = (phi0 + phi1) / 2
+    d_phi = phi1 - phi0
+    d_lambda = lamb1 - lamb0
+
+    f_A = lambda phi: (2 + 3*t(phi)**2 + 2*eta(phi)**2) / 24
+    f_B = lambda phi: ((t(phi)**2 - 1) * eta(phi)**2) / 8
+    # f_C = lambda phi: (t(phi)**2) / 24
+    f_D = lambda phi: (1 + eta(phi)**2 - 9 * eta(phi)**2 * t(phi)**2) / 24
+
+    F1 = lambda phi: d_phi * re.M(phi) * (1 - f_A(phi) * d_lambda ** 2 * cos(phi) ** 2 -
+                                          f_B(phi) * d_phi ** 2 / re.V(phi) ** 4)
+    F2 = lambda phi: d_lambda * re.N(phi) * cos(phi) * (1 - 1 / 24 * d_lambda ** 2 * sin(phi) ** 2 +
+                                                           f_D(phi) * d_phi ** 2 / re.V(phi) ** 4)
+
+    s = sqrt(F1(phi_0) ** 2 + F2(phi_0) ** 2)
+    A_0 = arctan(F2(phi_0) / F1(phi_0))
+    d_A = d_lambda * sin(phi_0) * (1 + (1 + eta(phi_0) ** 2) / 12 * s ** 2 * sin(A_0) ** 2 / re.N(phi_0) ** 2 +
+                                      (3 + 8 * eta(phi_0) ** 2) / 24 * s ** 2 * cos(A_0) ** 2 / re.N(phi_0) ** 2)
+
+    alpha0 = A_0 - d_A / 2
+    alpha1 = A_0 + d_A / 2
+
+    return alpha0, alpha1, s

nicht abgeben/GHA_biaxial/rk.py

@@ -0,0 +1,33 @@
+from typing import Tuple
+
+import numpy as np
+from ellipsoid_biaxial import EllipsoidBiaxial
+from numpy import cos, sin, tan
+from numpy.typing import NDArray
+
+import runge_kutta as rk
+
+
+def gha1(re: EllipsoidBiaxial, phi0: float, lamb0: float, alpha0: float, s: float, num: int) -> Tuple[float, float, float]:
+    """
+    Berechnung der 1. GHA auf einem Rotationsellipsoid mittels RK4
+    :param re:
+    :param phi0:
+    :param lamb0:
+    :param alpha0:
+    :param s:
+    :param num:
+    :return:
+    """
+    def buildODE():
+        def ODE(s: float, v: NDArray):
+            phi, lam, A = v
+            V = re.V(phi)
+            dphi = cos(A) * V ** 3 / re.c
+            dlam = sin(A) * V / (cos(phi) * re.c)
+            dA = tan(phi) * sin(A) * V / re.c
+            return np.array([dphi, dlam, dA])
+        return ODE
+
+    _, funktionswerte = rk.rk4(buildODE(), 0, np.array([phi0, lamb0, alpha0]), s, num)
+    return funktionswerte[-1][0], funktionswerte[-1][1], funktionswerte[-1][2]