kleine Anpassungen

GHA_triaxial/approx_gha2.py

@@ -83,16 +83,16 @@ def show_points(points: NDArray, points_app: NDArray, p0: NDArray, p1: NDArray):
 
 
 if __name__ == '__main__':
-    ell = EllipsoidTriaxial.init_name("BursaSima1980round")
+    ell = EllipsoidTriaxial.init_name("Bursa1970")
 
-    beta0, lamb0 = (0.2, 0.1)
+    beta0, lamb0 = (0.1, 0.1)
     P0 = ell.ell2cart(beta0, lamb0)
-    beta1, lamb1 = (0.7, 0.3)
+    beta1, lamb1 = (0.3, np.pi)
     P1 = ell.ell2cart(beta1, lamb1)
 
-    alpha0_app, alpha1_app, s_app, points = gha2_approx(ell, P0, P1, ds=1000, all_points=True)
+    alpha0_app, alpha1_app, s_app, points = gha2_approx(ell, P0, P1, ds=100, all_points=True)
     print("done")
-    alpha0, alpha1, s, betas, lambs = gha2_num(ell, beta0, lamb0, beta1, lamb1, n=5000, all_points=True)
+    alpha0, alpha1, s, betas, lambs = gha2_num(ell, beta0, lamb0, beta1, lamb1, n=10000, all_points=True)
     points_ana = []
     for beta, lamb in zip(betas, lambs):
         points_ana.append(ell.ell2cart(beta, lamb))

GHA_triaxial/panou.py

@@ -38,9 +38,11 @@ def pq_ell(ell: EllipsoidTriaxial, point: NDArray) -> Tuple[NDArray, NDArray]:
     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])
+    p = p / np.linalg.norm(p)
     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]])
+    q = q / np.linalg.norm(q)
 
     return p, q
 
@@ -141,6 +143,9 @@ def pq_para(ell: EllipsoidTriaxial, point: NDArray) -> Tuple[NDArray, NDArray]:
     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")
 
+    p = p / np.linalg.norm(p)
+    q = q / np.linalg.norm(q)
+
     return p, q
 
 def gha1_ana_step(ell: EllipsoidTriaxial, point: NDArray, alpha0: float, s: float, maxM: int) -> Tuple[NDArray, float]:
@@ -255,7 +260,7 @@ def gha1_ana(ell: EllipsoidTriaxial, point: NDArray, alpha0: float, s: float, ma
 
     _, _, h = ell.cart2geod(point_end, "ligas3")
     if h > 1e-5:
-        raise Exception("Analyitsche Methode ist explodiert, Punkt liegt nicht mehr auf dem Ellpsoid")
+        raise Exception("Analytische Methode ist explodiert, Punkt liegt nicht mehr auf dem Ellipsoid")
 
     return point_end, alpha_end
 

alpha_conversion_test.ipynb

@@ -0,0 +1,130 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2026-01-20T15:30:31.978159Z",
+     "start_time": "2026-01-20T15:30:31.835157Z"
+    }
+   },
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ],
+   "outputs": [],
+   "execution_count": 1
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2026-01-20T15:30:33.910807Z",
+     "start_time": "2026-01-20T15:30:32.803089Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "import winkelumrechnungen as wu\n",
+    "from ellipsoide import EllipsoidTriaxial\n",
+    "from GHA_triaxial.panou import alpha_ell2para, alpha_para2ell\n",
+    "import numpy as np"
+   ],
+   "id": "9ad815aea55574e3",
+   "outputs": [],
+   "execution_count": 2
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2026-01-20T15:33:40.785362Z",
+     "start_time": "2026-01-20T15:33:34.296487Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "ell = EllipsoidTriaxial.init_name(\"KarneyTest2024\")\n",
+    "diffs = []\n",
+    "for beta_deg in range(-180, 181, 45):\n",
+    "    for lamb_deg in range(-90, 91, 45):\n",
+    "        for alpha_deg in range(0, 360, 45):\n",
+    "            beta = wu.deg2rad(beta_deg)\n",
+    "            lamb = wu.deg2rad(lamb_deg)\n",
+    "            u, v = ell.ell2para(beta, lamb)\n",
+    "            alpha = wu.deg2rad(alpha_deg)\n",
+    "\n",
+    "            alpha_para_1, *_ = alpha_ell2para(ell, beta, lamb, alpha)\n",
+    "            alpha_ell_1, *_ = alpha_para2ell(ell, u, v, alpha_para_1)\n",
+    "            diff_1 = wu.deg2rad(abs(alpha_ell_1 - alpha))/3600\n",
+    "\n",
+    "            alpha_ell_2, *_ = alpha_para2ell(ell, u, v, alpha)\n",
+    "            alpha_para_2, *_ = alpha_ell2para(ell, beta, lamb, alpha_ell_2)\n",
+    "            diff_2 = wu.deg2rad(abs(alpha_para_2 - alpha))/3600\n",
+    "\n",
+    "            diffs.append((beta_deg, lamb_deg, alpha_deg, diff_1, diff_2))\n",
+    "diffs = np.array(diffs)"
+   ],
+   "id": "98b9b220118deb3f",
+   "outputs": [],
+   "execution_count": 6
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2026-01-20T15:33:50.497990Z",
+     "start_time": "2026-01-20T15:33:50.261115Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "i_max_ell = np.argmax(diffs[:, 3])\n",
+    "max_ell = diffs[i_max_ell, 3]\n",
+    "point_max_ell = diffs[i_max_ell, :3]\n",
+    "\n",
+    "i_max_para = np.argmax(diffs[:, 4])\n",
+    "max_para = diffs[i_max_para, 4]\n",
+    "point_max_para = diffs[i_max_para, :4]\n",
+    "\n",
+    "print(f'Für elliptisches Alpha = {point_max_ell[2]}° und beta = {point_max_ell[0]}°, lamb = {point_max_ell[1]}°: diff = {max_ell}\"')\n",
+    "print(f'Für parametrisches Alpha = {point_max_para[2]}° und beta = {point_max_para[0]}°, lamb = {point_max_para[1]}°: diff = {max_ell}\"')\n",
+    "pass"
+   ],
+   "id": "3c74b65b0e85e3c2",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Für elliptisches Alpha = 315.0° und beta = -90.0°, lamb = -90.0°: diff = 3.426945967752335e-05\"\n",
+      "Für parametrisches Alpha = 315.0° und beta = -90.0°, lamb = -90.0°: diff = 3.426945967752335e-05\"\n"
+     ]
+    }
+   ],
+   "execution_count": 7
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

ellipsoide.py

@@ -113,6 +113,7 @@ class EllipsoidTriaxial:
     def init_name(cls, name: str):
         """
         Mögliche Ellipsoide: BursaFialova1993, BursaSima1980, Eitschberger1978, Bursa1972, Bursa1970, BesselBiaxial
+        Panou et al (2020)
         :param name: Name des dreiachsigen Ellipsoids
         """
         if name == "BursaFialova1993":