Masterprojekt_V3/Campusnetz.ipynb

{
 "cells": [
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Hier werden alle verwendeten Pythonmodule importiert\n",
    "import Datenbank\n",
    "import Import\n",
    "import importlib\n",
    "import Koordinatentransformationen\n",
    "import sqlite3\n",
    "import Funktionales_Modell\n",
    "import Berechnungen\n",
    "import Parameterschaetzung\n",
    "import Stochastisches_Modell\n",
    "from Stochastisches_Modell import StochastischesModell\n",
    "import Export\n",
    "import Netzqualität_Genauigkeit\n",
    "import Datumsfestlegung"
   ],
   "id": "2bc687b1b4adb7bd",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "importlib.reload(Datenbank)\n",
    "importlib.reload(Import)\n",
    "# Anlegen der Datenbank, wenn nicht vorhanden\n",
    "pfad_datenbank = r\"Campusnetz.db\"\n",
    "Datenbank.Datenbank_anlegen(pfad_datenbank)\n",
    "\n",
    "# Import vervollständigen\n",
    "imp = Import.Import(pfad_datenbank)\n",
    "db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)"
   ],
   "id": "57fcd841405b7866",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Import der Koordinatendatei(en) vom Tachymeter\n",
    "pfad_datei = r\"Daten\\campsnetz_koordinaten_bereinigt.csv\"\n",
    "imp.import_koordinaten_lh_tachymeter(pfad_datei)"
   ],
   "id": "6ecde908841d1212",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "importlib.reload(Datenbank)\n",
    "db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
    "# Transformationen in ETRS89 / DREF91 Realisierung 2025\n",
    "print(db_zugriff.get_koordinaten(\"naeherung_lh\"))"
   ],
   "id": "daefb156198b46dc",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "importlib.reload(Datenbank)\n",
    "db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
    "# Transformationen in ETRS89 / DREF91 Realisierung 2025\n",
    "print(db_zugriff.get_koordinaten(\"naeherung_us\"))"
   ],
   "id": "ab62308d8c665e58",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "importlib.reload(Import)\n",
    "imp = Import.Import(pfad_datenbank)\n",
    "\n",
    "pfad_koordinaten_gnss = r\"Daten\\Koordinaten_OL_umliegend_bereinigt.csv\"\n",
    "# X, Y, Z der SAPOS-Stationen\n",
    "genauigkeit_sapos_referenzstationen = [0.05, 0.04, 0.09]\n",
    "\n",
    "imp.import_koordinaten_gnss(pfad_koordinaten_gnss, genauigkeit_sapos_referenzstationen)\n"
   ],
   "id": "b28afe0c64aa59d6",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Datumsgebende Koordinaten bestimmen\n",
    "importlib.reload(Datenbank)\n",
    "db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
    "\n",
    "liste_koordinaten_x = [10026]\n",
    "liste_koordinaten_y = [10059]\n",
    "liste_koordinaten_z = [10028]\n",
    "liste_koordinaten_x_y_z = [10008, 10001]\n",
    "\n",
    "db_zugriff.set_datumskoordinaten(liste_koordinaten_x, liste_koordinaten_y, liste_koordinaten_z, liste_koordinaten_x_y_z)\n",
    "\n",
    "# Datumgebende Koordinaten entfernen\n",
    "liste_koordinaten_x = [10026]\n",
    "liste_koordinaten_y = [10059]\n",
    "liste_koordinaten_z = [10028]\n",
    "liste_koordinaten_x_y_z = [10001]\n",
    "\n",
    "db_zugriff.set_datumskoordinaten_to_neupunkte(liste_koordinaten_x, liste_koordinaten_y, liste_koordinaten_z, liste_koordinaten_x_y_z)"
   ],
   "id": "ed9be38e35cfc619",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# ToDo: Sobald GNSS vorliegend Koordinaten im ETRS89 / DREF 91 (2025) daraus berechnen!\n",
    "#liste_koordinaten_naeherung_us = {\n",
    "#    10001: (3794874.984, 546741.752, 5080029.990),\n",
    "#    10002: (3794842.533, 546726.907, 5080071.133),\n",
    "#    10037: (3794774.148, 546955.423, 5080040.520),\n",
    "#    10044: (3794725.786, 546954.557, 5080084.411),\n",
    "#}\n",
    "\n",
    "\n",
    "#con = sqlite3.connect(pfad_datenbank)\n",
    "#cursor = con.cursor()\n",
    "#sql = \"\"\"\n",
    "#UPDATE Netzpunkte\n",
    "#SET naeherungx_us = ?, naeherungy_us = ?, naeherungz_us = ?\n",
    "#WHERE punktnummer = ?\n",
    "#\"\"\"\n",
    "#for punktnummer, (x, y, z) in #liste_koordinaten_naeherung_us.items():\n",
    "#    cursor.execute(sql, (x, y, z, punktnummer))\n",
    "#con.commit()\n",
    "#cursor.close()\n",
    "#con.close()"
   ],
   "id": "efa952a603ad1909",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# ToDo: Sobald GNSS-Daten vorliegen und die Berechnungen richtig sind, aufräumen!!!\n",
    "\n",
    "importlib.reload(Koordinatentransformationen)\n",
    "trafos = Koordinatentransformationen.Transformationen(pfad_datenbank)\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import itertools\n",
    "import numpy as np\n",
    "import sympy as sp\n",
    "\n",
    "db = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
    "dict_ausgangssystem = db.get_koordinaten(\"naeherung_lh\", \"Dict\")\n",
    "dict_zielsystem = db.get_koordinaten(\"naeherung_us\", \"Dict\")\n",
    "\n",
    "gemeinsame_punktnummern = sorted(set(dict_ausgangssystem.keys()) & set(dict_zielsystem.keys()))\n",
    "anzahl_gemeinsame_punkte = len(gemeinsame_punktnummern)\n",
    "\n",
    "liste_punkte_ausgangssystem = [dict_ausgangssystem[i] for i in gemeinsame_punktnummern]\n",
    "liste_punkte_zielsystem = [dict_zielsystem[i] for i in gemeinsame_punktnummern]\n",
    "\n",
    "def dist(a, b):\n",
    "    return float((a - b).norm())\n",
    "\n",
    "print(\"d(p2,p1)=\", dist(liste_punkte_ausgangssystem[1], liste_punkte_ausgangssystem[0]))\n",
    "print(\"d(P2,P1)=\", dist(liste_punkte_zielsystem[1], liste_punkte_zielsystem[0]))\n",
    "print(\"m0 ~\", dist(liste_punkte_zielsystem[1], liste_punkte_zielsystem[0]) /\n",
    "               dist(liste_punkte_ausgangssystem[1], liste_punkte_ausgangssystem[0]))\n",
    "\n",
    "\n",
    "def dist(a, b):\n",
    "    return float((a - b).norm())\n",
    "\n",
    "ratios = []\n",
    "pairs = list(itertools.combinations(range(len(liste_punkte_ausgangssystem)), 2))\n",
    "\n",
    "for i, j in pairs:\n",
    "    d_loc = dist(liste_punkte_ausgangssystem[i], liste_punkte_ausgangssystem[j])\n",
    "    d_ecef = dist(liste_punkte_zielsystem[i], liste_punkte_zielsystem[j])\n",
    "    if d_loc > 1e-6:\n",
    "        ratios.append(d_ecef / d_loc)\n",
    "\n",
    "print(\"Anzahl Ratios:\", len(ratios))\n",
    "print(\"min/mean/max:\", min(ratios), sum(ratios)/len(ratios), max(ratios))\n",
    "print(\"std:\", float(np.std(ratios)))\n",
    "\n",
    "S_loc = sum(liste_punkte_ausgangssystem, sp.Matrix([0,0,0])) / anzahl_gemeinsame_punkte\n",
    "S_ecef = sum(liste_punkte_zielsystem, sp.Matrix([0,0,0])) / anzahl_gemeinsame_punkte\n",
    "\n",
    "print(\"S_loc:\", S_loc)\n",
    "print(\"S_ecef:\", S_ecef)\n",
    "print(\"Delta:\", (S_ecef - S_loc).evalf(6))\n",
    "\n",
    "\n",
    "def dist(a, b):\n",
    "    return float((a - b).norm())\n",
    "\n",
    "n = len(liste_punkte_ausgangssystem)\n",
    "\n",
    "scores = []\n",
    "for i in range(n):\n",
    "    d_loc = []\n",
    "    d_ecef = []\n",
    "    for j in range(n):\n",
    "        if i == j:\n",
    "            continue\n",
    "        d_loc.append(dist(liste_punkte_ausgangssystem[i], liste_punkte_ausgangssystem[j]))\n",
    "        d_ecef.append(dist(liste_punkte_zielsystem[i], liste_punkte_zielsystem[j]))\n",
    "\n",
    "    d_loc = np.array(d_loc)\n",
    "    d_ecef = np.array(d_ecef)\n",
    "\n",
    "    # Verhältnisvektor; robust gegen Nullschutz\n",
    "    r = d_ecef / np.where(d_loc == 0, np.nan, d_loc)\n",
    "\n",
    "    # Streuung der Ratios für Punkt i\n",
    "    score = np.nanstd(r)\n",
    "    scores.append(score)\n",
    "\n",
    "for pn, sc in sorted(zip(gemeinsame_punktnummern, scores), key=lambda x: -x[1]):\n",
    "    print(pn, round(sc, 4))\n",
    "\n",
    "\n",
    "\n",
    "transformationsparameter = trafos.Helmerttransformation_Euler_Transformationsparameter_berechne()"
   ],
   "id": "ebb18479e06e53ab",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "importlib.reload(Koordinatentransformationen)\n",
    "trafos = Koordinatentransformationen.Transformationen(pfad_datenbank)\n",
    "\n",
    "koordinaten_transformiert = trafos.Helmerttransformation(transformationsparameter)\n",
    "print(koordinaten_transformiert)"
   ],
   "id": "2d2156381d974d94",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "importlib.reload(Datenbank)\n",
    "db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
    "\n",
    "db_zugriff.set_koordinaten(koordinaten_transformiert, \"naeherung_us\")"
   ],
   "id": "5a9e8f24709980d2",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Importieren der tachymetrischen Beobachtungen\n",
    "importlib.reload(Datenbank)\n",
    "db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
    "\n",
    "db_zugriff.get_instrument_liste(\"Tachymeter\")\n",
    "db_zugriff.set_instrument(\"Tachymeter\", \"Trimble S9\")\n",
    "db_zugriff.set_instrument(\"Nivellier\", \"Trimble DiNi 0.3\")\n",
    "db_zugriff.get_instrument_liste(\"Tachymeter\")"
   ],
   "id": "bb4c738edcf9ac6f",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "#Importieren der apriori Genauigkeitsinformationen\n",
    "#Zulässige Beobachtungsarten = \"Tachymeter_Richtung\", \"Tachymeter_Strecke\"\n",
    "# Wenn Beobachtungsart = \"Tachymeter_Richtung\" --> Übergabe in Milligon und nur Stabw_apriori_konst\n",
    "# Wenn Beobachtungsart = \"Tachymeter_Strecke\" --> Übergabe Stabw_apriori_konst in Millimeter und Stabw_apriori_streckenprop in ppm\n",
    "\n",
    "importlib.reload(Datenbank)\n",
    "db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
    "importlib.reload(Berechnungen)\n",
    "\n",
    "db_zugriff.set_genauigkeiten(1, \"Tachymeter_Richtung\", 0.15)\n",
    "db_zugriff.set_genauigkeiten(1, \"Tachymeter_Strecke\", 0.8, 1)\n",
    "db_zugriff.set_genauigkeiten(1, \"Tachymeter_Zenitwinkel\", 0.15)"
   ],
   "id": "c2db29680c53f8c4",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Importieren der tachymetrischen Beobachtungen\n",
    "importlib.reload(Import)\n",
    "imp = Import.Import(pfad_datenbank)\n",
    "\n",
    "pfad_datei_tachymeterbeobachtungen = r\"Daten\\campsnetz_beobachtungen_bereinigt.csv\"\n",
    "\n",
    "imp.import_beobachtungen_tachymeter(pfad_datei_tachymeterbeobachtungen, 1)"
   ],
   "id": "3d074282dffbbfd0",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Importieren der Normalhöhen der HFP\n",
    "importlib.reload(Datenbank)\n",
    "db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
    "\n",
    "liste_HFP = [(666, 3.891), (812, 3.999), (816, 3.995)]\n",
    "\n",
    "db_zugriff.set_normalhoehe_hfp(liste_HFP)"
   ],
   "id": "da3bd8e134a3fe5c",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "importlib.reload(Datenbank)\n",
    "db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
    "\n",
    "db_zugriff.get_normalhoehe_hfp()"
   ],
   "id": "ded7bfe9e696a09d",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Nivellement-Beobachtungen Importieren Teil 1\n",
    "\n",
    "importlib.reload(Import)\n",
    "imp = Import.Import(pfad_datenbank)\n",
    "dict_punkthoehen_naeherung_niv, liste_punkte_in_db = imp.vorbereitung_import_beobachtungen_nivellement_naeherung_punkthoehen(r\"Daten\\Niv_bereinigt.DAT.csv\", 2)"
   ],
   "id": "1f61a51b2a7366e7",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Nivellement-Beobachtungen Importieren Teil 2\n",
    "\n",
    "importlib.reload(Import)\n",
    "imp = Import.Import(pfad_datenbank)\n",
    "liste_hoehenpunkte_hinzufuegen = ['FH14', 'FH11', 'FH13', 'FH3', 'FH4', 'FH15', 'FH5']\n",
    "imp.import_beobachtungen_nivellement_naeherung_punkthoehen(dict_punkthoehen_naeherung_niv, liste_punkte_in_db, liste_hoehenpunkte_hinzufuegen)"
   ],
   "id": "6c909b9792861b30",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Nivellement-Beobachtungen Importieren Teil 3\n",
    "importlib.reload(Import)\n",
    "imp = Import.Import(pfad_datenbank)\n",
    "imp.import_beobachtungen_nivellement_RVVR(r\"Daten\\Niv_bereinigt.DAT.csv\", 2)"
   ],
   "id": "4c06b9c4cd78e7b7",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Jacobimatrix aufstellen\n",
    "importlib.reload(Datenbank)\n",
    "db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
    "\n",
    "# Parameter des GRS80-ellipsoids (Bezugsellipsoid des ETRS89 / DREF 91 (2025)\n",
    "# ToDo: Quelle mit möglichst genauen Parametern heraussuchen!\n",
    "a = 6378137.0 #m\n",
    "b = 63567552.314 #m\n",
    "\n",
    "importlib.reload(Funktionales_Modell)\n",
    "fm = Funktionales_Modell.FunktionalesModell(pfad_datenbank, a, b)\n",
    "\n",
    "#db_zugriff.get_beobachtungen_id_standpunkt_zielpunkt(\"tachymeter_distanz\")\n",
    "Jacobimatrix_symbolisch = fm.jacobi_matrix_symbolisch()[0]\n",
    "Jacobimatrix_symbolisch_liste_unbekannte = fm.jacobi_matrix_symbolisch()[1]\n",
    "Jacobimatrix_symbolisch_liste_beobachtungsvektor = fm.jacobi_matrix_symbolisch()[2]"
   ],
   "id": "c9367690f5b73953",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "importlib.reload(Datenbank)\n",
    "db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
    "importlib.reload(Funktionales_Modell)\n",
    "fm = Funktionales_Modell.FunktionalesModell(pfad_datenbank, a, b)\n",
    "\n",
    "A_matrix_numerisch_iteration0 = fm.jacobi_matrix_zahlen_iteration_0(Jacobimatrix_symbolisch, \"naeherung_us\", Jacobimatrix_symbolisch_liste_unbekannte, Jacobimatrix_symbolisch_liste_beobachtungsvektor)"
   ],
   "id": "163fa2e24923b40",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "importlib.reload(Funktionales_Modell)\n",
    "fm = Funktionales_Modell.FunktionalesModell(pfad_datenbank, a, b)\n",
    "\n",
    "beobachtungsvektor_numerisch = fm.beobachtungsvektor_numerisch(Jacobimatrix_symbolisch_liste_beobachtungsvektor)"
   ],
   "id": "80e8325721c950f8",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "importlib.reload(Funktionales_Modell)\n",
    "fm = Funktionales_Modell.FunktionalesModell(pfad_datenbank, a, b)\n",
    "\n",
    "beobachtungsvektor_naeherung_symbolisch = fm.beobachtungsvektor_naeherung_symbolisch(Jacobimatrix_symbolisch_liste_beobachtungsvektor)"
   ],
   "id": "33e9fbd465c577e4",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "importlib.reload(Funktionales_Modell)\n",
    "fm = Funktionales_Modell.FunktionalesModell(pfad_datenbank, a, b)\n",
    "\n",
    "beobachtungsvektor_naeherung_numerisch_iteration0 = fm.beobachtungsvektor_naeherung_numerisch_iteration0(Jacobimatrix_symbolisch_liste_beobachtungsvektor, beobachtungsvektor_naeherung_symbolisch)"
   ],
   "id": "bcf3dd5fc820d077",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Auftstellen der Qll-Matrix\n",
    "importlib.reload(Stochastisches_Modell)\n",
    "stoch_modell = Stochastisches_Modell.StochastischesModell(A_matrix_numerisch_iteration0.rows)\n",
    "\n",
    "Qll_matrix_symbolisch = stoch_modell.Qll_symbolisch(pfad_datenbank, Jacobimatrix_symbolisch_liste_beobachtungsvektor)\n",
    "Qll_matrix_numerisch = stoch_modell.Qll_numerisch(pfad_datenbank, Qll_matrix_symbolisch,Jacobimatrix_symbolisch_liste_beobachtungsvektor)"
   ],
   "id": "63c4db5423f4fbaf",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": "",
   "id": "56d21ad3a21bcb23",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": "",
   "id": "62ce1bc475e81e81",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": "",
   "id": "275c60800b458eae",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "importlib.reload(Funktionales_Modell)\n",
    "fm = Funktionales_Modell.FunktionalesModell(pfad_datenbank, a, b)\n",
    "\n",
    "importlib.reload(Parameterschaetzung)\n",
    "importlib.reload(Stochastisches_Modell)\n",
    "\n",
    "importlib.reload(Netzqualität_Genauigkeit)\n",
    "importlib.reload(Export)\n",
    "\n",
    "\n",
    "stoch_modell = Stochastisches_Modell.StochastischesModell(A_matrix_numerisch_iteration0.rows)\n",
    "\n",
    "dx = Parameterschaetzung.ausgleichung_global(A_matrix_numerisch_iteration0, fm.berechnung_dl(beobachtungsvektor_numerisch, beobachtungsvektor_naeherung_numerisch_iteration0), stoch_modell)[1]"
   ],
   "id": "d114b64c8acc8c50",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Von Fabian\n",
    "\n",
    "importlib.reload(Funktionales_Modell)\n",
    "fm = Funktionales_Modell.FunktionalesModell(pfad_datenbank, a, b)\n",
    "importlib.reload(Export)\n",
    "importlib.reload(Datenbank)\n",
    "\n",
    "unbekanntenvektor_symbolisch = (fm.unbekanntenvektor_symbolisch(Jacobimatrix_symbolisch_liste_unbekannte))\n",
    "unbekanntenvektor_numerisch_iteration0 = fm.unbekanntenvektor_numerisch(Jacobimatrix_symbolisch_liste_unbekannte, unbekanntenvektor_symbolisch)\n",
    "print(unbekanntenvektor_numerisch_iteration0)\n",
    "print(\"-----\")\n",
    "unbekanntenvektor_numerisch = fm.unbekanntenvektor_numerisch(Jacobimatrix_symbolisch_liste_unbekannte, unbekanntenvektor_symbolisch, dx, unbekanntenvektor_numerisch_iteration0)\n",
    "print(unbekanntenvektor_numerisch)"
   ],
   "id": "80c2cf1889ea56c8",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-12-30T10:11:25.614597Z",
     "start_time": "2025-12-30T10:11:24.213436Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import importlib\n",
    "import Netzqualität_Genauigkeit\n",
    "importlib.reload(Netzqualität_Genauigkeit)\n",
    "\n",
    "import Parameterschaetzung\n",
    "importlib.reload(Parameterschaetzung)"
   ],
   "id": "dae9ff512fb17160",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'Parameterschaetzung' from 'C:\\\\Users\\\\miche\\\\PycharmProjects\\\\Masterprojekt_V3\\\\Parameterschaetzung.py'>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 1
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-12-30T10:11:28.574122Z",
     "start_time": "2025-12-30T10:11:28.181972Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import sympy as sp\n",
    "\n",
    "# -----------------------------\n",
    "# 1) Punktliste aus Unbekannten ableiten (konsistent zur A-Matrix!)\n",
    "# -----------------------------\n",
    "liste_punktnummern = []\n",
    "for sym in Jacobimatrix_symbolisch_liste_unbekannte:\n",
    "    name = str(sym)\n",
    "    if name.startswith(\"X\"):              # X10001, X10002, ...\n",
    "        liste_punktnummern.append(name[1:])  # \"10001\", ...\n",
    "\n",
    "# -----------------------------\n",
    "# 2) idx_X / idx_Y / idx_Z passend zur Punktliste\n",
    "# (weil Unbekanntenreihenfolge pro Punkt: X,Y,Z)\n",
    "# -----------------------------\n",
    "nP = len(liste_punktnummern)\n",
    "idx_X = [3*p for p in range(nP)]\n",
    "idx_Y = [3*p + 1 for p in range(nP)]\n",
    "idx_Z = [3*p + 2 for p in range(nP)]\n",
    "\n",
    "# -----------------------------\n",
    "# 3) Datumsauswahl (gemischt möglich) -> aktive Indizes\n",
    "# -----------------------------\n",
    "auswahl = [(pt, c) for pt in liste_punktnummern for c in (\"X\",\"Y\",\"Z\")]\n",
    "\n",
    "aktive_unbekannte_indices = Datumsfestlegung.Datumsfestlegung.datumskomponenten(\n",
    "    auswahl,\n",
    "    liste_punktnummern\n",
    ")\n",
    "\n",
    "# -----------------------------\n",
    "# 4) Startwerte x(0) aus den vorhandenen Substitutionen (Iteration 0)\n",
    "# Alles, was nicht im Dict ist (z.B. Orientierungen), wird 0.0 gesetzt.\n",
    "basis_subs = fm.substitutionen_dict\n",
    "\n",
    "x = sp.Matrix([[float(basis_subs.get(sym, 0.0))] for sym in Jacobimatrix_symbolisch_liste_unbekannte])\n",
    "\n",
    "# 5) Iteration mit lokaler Ausgleichung + Teilspur\n",
    "max_iter = 1\n",
    "tol = 1e-4  # m\n",
    "\n",
    "for it in range(max_iter):\n",
    "\n",
    "    # a) Substitutionen für diese Iteration: Basis + aktuelle Unbekannte\n",
    "    subs_it = dict(basis_subs)\n",
    "    for sym, val in zip(Jacobimatrix_symbolisch_liste_unbekannte, list(x)):\n",
    "        subs_it[sym] = float(val)\n",
    "\n",
    "    # b) A(x) numerisch aus symbolischer Jacobi\n",
    "    A_it = Jacobimatrix_symbolisch.xreplace(subs_it)\n",
    "\n",
    "    # c) l0(x) numerisch aus symbolischem Näherungs-Beobachtungsvektor\n",
    "    l0_it = beobachtungsvektor_naeherung_symbolisch.xreplace(subs_it)\n",
    "\n",
    "    # d) dl = l - l0\n",
    "    dl_it = beobachtungsvektor_numerisch - l0_it\n",
    "\n",
    "    # e) lokale Ausgleichung\n",
    "    res_dict, dx = Parameterschaetzung.ausgleichung_lokal(\n",
    "        A=A_it,\n",
    "        dl=dl_it,\n",
    "        Q_ll=Qll_matrix_numerisch,\n",
    "        x0=x,\n",
    "        liste_punktnummern=liste_punktnummern,\n",
    "        auswahl=auswahl,\n",
    "        mit_massstab=False\n",
    "    )\n",
    "\n",
    "    x = x + dx\n",
    "\n",
    "    # f) Abbruchkriterium\n",
    "    max_abs_dx = max(abs(float(v)) for v in dx)\n",
    "    print(\n",
    "    f\"Iter {it}: max|dx| = {max_abs_dx:.3e} m, \"\n",
    "    f\"r_gesamt={res_dict.get('r_gesamt', None)}, \"\n",
    "    f\"sigma0={res_dict.get('sigma0_apost', None)}\"\n",
    "    )\n",
    "    print(\"l  :\", float(beobachtungsvektor_numerisch[0]))\n",
    "    print(\"l0 :\", float(l0_it[0]))\n",
    "    print(\"dl :\", float(dl_it[0]))\n",
    "\n",
    "\n",
    "    if max_abs_dx < tol:\n",
    "        print(\"Konvergenz erreicht.\")\n",
    "        break\n",
    "\n",
    "# Ergebnis: x enthält die geschätzten Unbekannten nach letzter Iteration\n",
    "x"
   ],
   "id": "cd09dd5a716736b1",
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'Jacobimatrix_symbolisch_liste_unbekannte' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001B[31m---------------------------------------------------------------------------\u001B[39m",
      "\u001B[31mNameError\u001B[39m                                 Traceback (most recent call last)",
      "\u001B[36mCell\u001B[39m\u001B[36m \u001B[39m\u001B[32mIn[2]\u001B[39m\u001B[32m, line 7\u001B[39m\n\u001B[32m      3\u001B[39m \u001B[38;5;66;03m# -----------------------------\u001B[39;00m\n\u001B[32m      4\u001B[39m \u001B[38;5;66;03m# 1) Punktliste aus Unbekannten ableiten (konsistent zur A-Matrix!)\u001B[39;00m\n\u001B[32m      5\u001B[39m \u001B[38;5;66;03m# -----------------------------\u001B[39;00m\n\u001B[32m      6\u001B[39m liste_punktnummern = []\n\u001B[32m----> \u001B[39m\u001B[32m7\u001B[39m \u001B[38;5;28;01mfor\u001B[39;00m sym \u001B[38;5;129;01min\u001B[39;00m \u001B[43mJacobimatrix_symbolisch_liste_unbekannte\u001B[49m:\n\u001B[32m      8\u001B[39m     name = \u001B[38;5;28mstr\u001B[39m(sym)\n\u001B[32m      9\u001B[39m     \u001B[38;5;28;01mif\u001B[39;00m name.startswith(\u001B[33m\"\u001B[39m\u001B[33mX\u001B[39m\u001B[33m\"\u001B[39m):              \u001B[38;5;66;03m# X10001, X10002, ...\u001B[39;00m\n",
      "\u001B[31mNameError\u001B[39m: name 'Jacobimatrix_symbolisch_liste_unbekannte' is not defined"
     ]
    }
   ],
   "execution_count": 2
  }
 ],
 "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
}