fa2338/Masterprojekt_V3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Push

Browse Source
This commit is contained in:
fa2338
2026-02-05 14:45:27 +01:00
parent e0796deec6
commit 65b390bf2d
8 changed files with 868 additions and 59323 deletions
Download Patch File Download Diff File Expand all files Collapse all files

853
Ausgleichungsprogramm.ipynb Normal file
View File

@@ -0,0 +1,853 @@
{
"cells": [
{
"cell_type": "code",
"id": "2bc687b1b4adb7bd",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:09.512813Z",
"start_time": "2026-02-05T12:24:07.910581Z"
}
},
"source": [
"# Zelle 1: Import von Python-Modulen und Bibliotheken\n",
"\n",
"from datetime import datetime\n",
"import importlib\n",
"from IPython.display import HTML\n",
"from IPython.display import display\n",
"import numpy as np\n",
"import pandas as pd\n",
"\n",
"import Berechnungen\n",
"import Datenbank\n",
"import Export\n",
"import Funktionales_Modell\n",
"import Import\n",
"import Koordinatentransformationen\n",
"import Netzqualitaet_Genauigkeit\n",
"import Netzqualitaet_Zuverlaessigkeit\n",
"from Parameterschaetzung import Iterationen\n",
"import Proben\n",
"import Varianzkomponentenschaetzung"
],
"outputs": [],
"execution_count": 1
},
{
"cell_type": "code",
"id": "4f7efd7ba6ec18f9",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:09.522346Z",
"start_time": "2026-02-05T12:24:09.520187Z"
}
},
"source": [
"# Zelle 2: Allgemeine Einstellungen\n",
"\n",
"# Auswahl der Datumsdefinition (Aktuell ist lediglich die weiche Lagerung implementiert)\n",
"datumfestlegung = \"weiche Lagerung\"\n",
"\n",
"# Übergabe der großen und kleinen Halbachse des Referenzellipsoids (aktuell GRS80)\n",
"a = 6378137.0 #m\n",
"b = 6356752.314 #m\n",
"\n",
"# Pfad zur SQLite-Datenbank (wird angelegt, falls nicht vorhanden)\n",
"pfad_datenbank = r\"Campusnetz.db\"\n",
"\n",
"# Pfad zum Quasigeoid-Modell GCG 2016 des BKG\n",
"pfad_tif_quasigeoidundolation = r\"Daten\\GCG2016v2023.tif\"\n",
"\n",
"# Alle während jeder Iteration der Parameterschätzung erstellten Vektoren und Matrizenin einer CSV-Datei im Ordner Zwischenergebnisse speichern (Auf True setzen, wenn gewünscht)\n",
"speichern_in_csv = False"
],
"outputs": [],
"execution_count": 2
},
{
"cell_type": "code",
"id": "57fcd841405b7866",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:09.763148Z",
"start_time": "2026-02-05T12:24:09.708149Z"
}
},
"source": [
"# Zelle 3: SQLite-Datenbank initialisieren und Klassen laden\n",
"\n",
"# Datenbank anlegen (falls nicht vorhanden)\n",
"Datenbank.Datenbank_anlegen(pfad_datenbank)\n",
"\n",
"# Klassen aus eigenen Pythondateien initialisieren\n",
"db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)\n",
"fm = Funktionales_Modell.FunktionalesModell(pfad_datenbank, a, b, pfad_tif_quasigeoidundolation)\n",
"imp = Import.Import(pfad_datenbank, a, b)\n",
"iterat = Iterationen(pfad_datenbank, pfad_tif_quasigeoidundolation, a, b)\n",
"trafos = Koordinatentransformationen.Transformationen(pfad_datenbank)\n",
"vks = Varianzkomponentenschaetzung.VKS(pfad_datenbank)"
],
"outputs": [],
"execution_count": 3
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:10.248982Z",
"start_time": "2026-02-05T12:24:10.242901Z"
}
},
"cell_type": "code",
"source": [
"# Zelle 4: Ausgabe der bereits vorhandenen Instrumente\n",
"\n",
"db_zugriff.tabelle_instrumente_aus_db()"
],
"id": "2cf681b8ca7f268",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Es wurden noch keine Instrumente angelegt. Bitte in der folgenden Zelle nachholen und diese Zelle erneut ausführen!\n"
]
}
],
"execution_count": 4
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:10.710361Z",
"start_time": "2026-02-05T12:24:10.684088Z"
}
},
"cell_type": "code",
"source": [
"# Zelle 5: Instrumente anlegen\n",
"\n",
"# Syntax: db_zugriff.set_instrument(Instrumententyp, Bezeichnung, [Beobachtungsgruppen])\n",
"# Hinweis: Alle GNSS-Rover sind als ein Instrument anzulegen!\n",
"# Sind Instrumente bereits in der Datenbank vorhanden, wird der Import übersprungen.\n",
"# Änderungen an bestehenden Instrumenten sind nicht möglich. In diesem Fall ist ein neues Instrument anlegen.\n",
"\n",
"db_zugriff.set_instrument(\n",
" \"Tachymeter\", \"Trimble S9\", [\"Tachymeter_Streckenbeobachtungen\", \"Tachymeter_Richtungsbeobachtungen\", \"Tachymeter_Zenitwinkelbeobachtungen\"\n",
" ])\n",
"db_zugriff.set_instrument(\n",
" \"Nivellier\", \"Trimble DiNi 0.3\", [\"Nivellier_Hoehendifferenzbeobachtungen\"\n",
" ])\n",
"db_zugriff.set_instrument(\n",
" \"GNSS\", \"GNSS-Rover\", [\"GNSS-Rover_Basislinienbeobachtungen\"\n",
" ])"
],
"id": "990c372312c1d8f9",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Das Instrument Trimble S9 wurde erfolgreich hinzugefügt.\n",
"Das Instrument Trimble DiNi 0.3 wurde erfolgreich hinzugefügt.\n",
"Das Instrument GNSS-Rover wurde erfolgreich hinzugefügt.\n"
]
}
],
"execution_count": 5
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:11.161918Z",
"start_time": "2026-02-05T12:24:11.156510Z"
}
},
"cell_type": "code",
"source": [
"# Zelle 6: Ausgabe der bereits vorhandenen Genauigkeitsangaben a-priori\n",
"\n",
"db_zugriff.tabelle_genauigkeiten_aus_db()"
],
"id": "3a90f746c44a1ebb",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Es wurden noch keine apriori Genauigkeiten zu den Beobachtungsgruppen erfasst. Bitte in der folgenden Zelle nachholen und diese Zelle erneut ausführen.\n"
]
}
],
"execution_count": 6
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:11.784546Z",
"start_time": "2026-02-05T12:24:11.763928Z"
}
},
"cell_type": "code",
"source": [
"# Zelle 7: Genauigkeiten a-priori zu den Instrumenten erfassen\n",
"\n",
"# Syntax: db_zugriff.set_genauigkeiten(InstrumentenID, Beobachtungsgruppe, Standardabweichung_konstant, Standardabweichung_streckenproportional)\n",
"\n",
"# Einheit der Eingaben:\n",
"# - stabw_konstant:\n",
"# - Winkelbeobachtungen (Richtung, Zenitwinkel): Standardabweichung in mgon\n",
"# - Strecken: Standardabweichung in m (auf die Strecke bezogener absoluter Anteil)\n",
"# - Nivellement: Standardabweichung in m pro 1 km Doppelnivellement\n",
"# - stabw_streckenproportional (optional): streckenproportionaler Anteil in ppm\n",
"\n",
"# Sind Genauigkeitsangaben bereits in der Datenbank vorhanden, wird der Import übersprungen.\n",
"# Änderungen sind möglich.\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)\n",
"db_zugriff.set_genauigkeiten(3, \"Geometrisches_Nivellement\", 0.1, 0.3)"
],
"id": "107d51b8dd3b82cf",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Die Genauigkeitsangabe für Tachymeter_Richtung (Instrument: Trimble S9) wurde erfolgreich hinzugefügt.\n",
"Die Genauigkeitsangabe für Tachymeter_Strecke (Instrument: Trimble S9) wurde erfolgreich hinzugefügt.\n",
"Die Genauigkeitsangabe für Tachymeter_Zenitwinkel (Instrument: Trimble S9) wurde erfolgreich hinzugefügt.\n",
"Die Genauigkeitsangabe für Geometrisches_Nivellement (Instrument: Trimble DiNi 0.3) wurde erfolgreich hinzugefügt.\n"
]
}
],
"execution_count": 7
},
{
"cell_type": "code",
"id": "b28afe0c64aa59d6",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:12.490480Z",
"start_time": "2026-02-05T12:24:12.356523Z"
}
},
"source": [
"# Zelle 8: Import Tachymeter-Datensätze\n",
"# Hinweis: Sind die Dateien bereits für den Import verwendet worden, wird der Import abgebrochen.\n",
"\n",
"# CSV-Datei mit den Koordinaten im Lokalen-Horizontsystem aus dem Tachymeterexport\n",
"pfad_datei_tachymeter_koordinaten = r\"Daten\\campsnetz_koordinaten_plus_nachmessungen.csv\"\n",
"\n",
"# CSV-Datei mit den Beobachtungen aus dem Tachymeterexport\n",
"pfad_datei_tachymeter_beobachtungen_csv = r\"Daten\\campsnetz_beobachtungen_plus_nachmessungen.csv\"\n",
"\n",
"# JXL-Datei mit den Beobachtungen aus dem Tachymeterexport (für die Korrektur der gerundeten Daten in der CSV-Datei)\n",
"pfad_datei_tachymeter_beobachtungen_jxl = r\"Daten\\campusnetz_bereinigt_plus_nachmessung_neu.jxl\"\n",
"\n",
"# Dateiname der korrigierten und erweiterten CSV-Datei mit den Tachymeterbeobachtungen\n",
"pfad_datei_tachymeterbeobachtungen_korrigiert = r\"Daten\\campsnetz_beobachtungen_plus_nachmessungen_korrigiert.csv\"\n",
"\n",
"# InstrumentenID des Tachymeters (siehe Zelle 4)\n",
"instrumentenID_Tachymeter = 1\n",
"\n",
"# Verarbeitung und Import der Tachymeterdatensätze\n",
"imp.import_koordinaten_lh_tachymeter(pfad_datei_tachymeter_koordinaten)\n",
"imp.korrigiere_beobachtungen_tachymeter_csv_mit_jxl(pfad_datei_tachymeter_beobachtungen_csv, pfad_datei_tachymeter_beobachtungen_jxl, pfad_datei_tachymeterbeobachtungen_korrigiert)\n",
"imp.import_beobachtungen_tachymeter(pfad_datei_tachymeterbeobachtungen_korrigiert, instrumentenID_Tachymeter)"
],
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Der Import der Näherungskoordinaten wurde erfolgreich abgeschlossen\n",
"Korrektur erfolgreich abgeschlossen. Ausgabe: Daten\\campsnetz_beobachtungen_plus_nachmessungen_korrigiert.csv\n",
"Ersetzungen in der CSV-Datei (Rundung -> JXL volle Nachkommastellen): {'Hz': 1639, 'Z': 1838, 'SD': 747}\n",
"Der Import der Datei Daten\\campsnetz_beobachtungen_plus_nachmessungen_korrigiert.csv wurde erfolgreich abgeschlossen.\n"
]
}
],
"execution_count": 8
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:12.916365Z",
"start_time": "2026-02-05T12:24:12.899749Z"
}
},
"cell_type": "code",
"source": [
"# Zelle 9: Import GNSS-Datensätze\n",
"# Hinweis: Sind die Dateien bereits importiert, wird der Import übersprungen.\n",
"\n",
"# CSV-Datei mit den Koordinaten der statischen GNSS-Messung als export aus LeicaGeoOffice\n",
"pfad_koordinaten_gnss = r\"Daten\\Koordinaten_ohne0648und10002.csv\"\n",
"\n",
"# TXT-Datei mit den Basislinien und den Kovarianzen als Export aus LeicaGeoOffice\n",
"pfad_basislinien_gnss = r\"Daten\\Basislinien_ohne0648und10002.asc.txt\"\n",
"\n",
"# Standardabweichung a priori der Koordinaten der SAPOS-Referenzstationen in X, Y und Z für die weiche Lagerung\n",
"genauigkeit_sapos_referenzstationen = [0.005, 0.005, 0.008]\n",
"\n",
"# InstrumentenID aller GNSS-Empfänger (siehe Zelle 4)\n",
"instrumentenID_GNSS_Empfaenger = 4\n",
"\n",
"# Import ausführen\n",
"imp.import_koordinaten_gnss(pfad_koordinaten_gnss, genauigkeit_sapos_referenzstationen)\n",
"imp.import_basislinien_gnss(pfad_basislinien_gnss, instrumentenID_GNSS_Empfaenger)"
],
"id": "75d9d9edbbbc7bb7",
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Der Import der Datei Daten\\Basislinien_ohne0648und10002.asc.txt wurde erfolgreich abgeschlossen.\n"
]
}
],
"execution_count": 9
},
{
"cell_type": "code",
"id": "2d8a0533726304a8",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:14.974452Z",
"start_time": "2026-02-05T12:24:13.540713Z"
}
},
"source": [
"# Zelle 10: Helmerttransformation\n",
"\n",
"# Transformationsparameter zwischen lokalem-Horizontsystem aus dem Tachymeterexport und ETRS89 / DREF 91 (Realisierung 2025) berechnen\n",
"transformationsparameter = trafos.Helmerttransformation_Euler_Transformationsparameter_berechnen()\n",
"\n",
"# Transformationsparameter anwenden und Koordinaten im Zielsystem berechnen\n",
"koordinaten_transformiert = trafos.Helmerttransformation(transformationsparameter)\n",
"\n",
"# Koordinaten als Näherungen für die Ausgleichung in die Datenbank speichern\n",
"db_zugriff.set_koordinaten(koordinaten_transformiert, \"naeherung_us\")"
],
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Anzahl verwendete Punkte für die Helmerttransformation: 9\n",
"Iteration Nr.1 abgeschlossen\n",
"Iteration Nr.2 abgeschlossen\n",
"Iteration Nr.3 abgeschlossen\n",
"Iteration Nr.4 abgeschlossen\n",
"Iteration Nr.5 abgeschlossen\n",
"Iteration Nr.6 abgeschlossen\n",
"Koordinaten berechnet aus Helmerttransformation:\n",
"10001: 3794901.521, 546745.584, 5080065.755\n",
"10008: 3794783.870, 546746.646, 5080152.758\n",
"10014: 3794838.746, 546812.367, 5080105.181\n",
"10026: 3794753.858, 546827.445, 5080167.092\n",
"10028: 3794889.671, 546908.764, 5080056.920\n",
"10037: 3794800.626, 546960.749, 5080117.709\n",
"10044: 3794752.686, 546958.324, 5080154.237\n",
"10054: 3794889.163, 547086.949, 5080038.116\n",
"10059: 3794736.830, 547079.447, 5080152.362\n",
"Streckendifferenzen zwischen Näherungskoordinate aus statischer GNSS-Messung und ergebnis der Helmerttransformation:\n",
"[0.027793, 0.025879, 0.016527, 0.01604, 0.066139, 0.07164, 0.025138, 0.125881, 0.142477]\n",
"\n",
"Differenz Schwerpunkt zwischen Näherungskoordinate aus statischer GNSS-Messung und ergebnis der Helmerttransformation::\n",
"Matrix([[3.10e-10], [1.16e-10], [1.03e-10]])\n",
"Betrag der Schwerpunkt-Differenz zwischen Näherungskoordinate aus statischer GNSS-Messung und ergebnis der Helmerttransformation::\n",
"0.000m\n"
]
}
],
"execution_count": 10
},
{
"cell_type": "code",
"id": "ed9be38e35cfc619",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:15.067892Z",
"start_time": "2026-02-05T12:24:15.058891Z"
}
},
"source": [
"# Zelle 11: Anschlusspunkte für die weiche Lagerung festlegen\n",
"# Definieren Sie hier die Punktnummern, die als Anschlusspunkte für die weiche Lagerung verwendet werden sollen.\n",
"\n",
"# X-Koordinate der Punkte verwenden\n",
"liste_koordinaten_x = []\n",
"\n",
"# Y-Koordinate der Punkte verwenden\n",
"liste_koordinaten_y = []\n",
"\n",
"# Z-Koordinate der Punkte verwenden\n",
"liste_koordinaten_z = []\n",
"\n",
"# X, Y und Z-Koordinate der Punkte verwenden\n",
"liste_koordinaten_x_y_z = [\"0645\", \"0656\", \"0995\", \"1675\", \"ESTE\", \"GNA2\"]\n",
"\n",
"# Änderungen der zu verwendenden Anschlusspunkte in die Datenbank übernehmen\n",
"db_zugriff.set_datumskoordinaten(liste_koordinaten_x, liste_koordinaten_y, liste_koordinaten_z, liste_koordinaten_x_y_z)"
],
"outputs": [],
"execution_count": 11
},
{
"cell_type": "code",
"id": "2d2156381d974d94",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:15.151220Z",
"start_time": "2026-02-05T12:24:15.146192Z"
}
},
"source": [
"# Zelle 12: Anschlusspunkte für die weiche Lagerung entfernen\n",
"# Definieren Sie hier die Punktnummern, die aus den Anschlusspunkten entfernt werden sollen.\n",
"\n",
"# X-Koordinate der Punkte entfernen\n",
"liste_koordinaten_x = []\n",
"\n",
"# Y-Koordinate der Punkte verwenden\n",
"liste_koordinaten_y = []\n",
"\n",
"# Z-Koordinate der Punkte verwenden\n",
"liste_koordinaten_z = []\n",
"\n",
"# X, Y und Z-Koordinate der Punkte verwenden\n",
"liste_koordinaten_x_y_z = []\n",
"\n",
"# Änderungen der zu verwendenden Anschlusspunkte in die Datenbank übernehmen\n",
"db_zugriff.set_datumskoordinaten_to_neupunkte(liste_koordinaten_x, liste_koordinaten_y, liste_koordinaten_z, liste_koordinaten_x_y_z)"
],
"outputs": [],
"execution_count": 12
},
{
"cell_type": "code",
"id": "c2db29680c53f8c4",
"metadata": {
"ExecuteTime": {
"end_time": "2026-02-05T12:24:15.928494Z",
"start_time": "2026-02-05T12:24:15.908077Z"
}
},
"source": [
"# Zelle 13: Nivellement-Beobachtungen importieren\n",
"# Hinweis: Ist die Datei bereits importiert, wird der Import übersprungen.\n",
"\n",
"# CSV-Datei mit den Beobachtungen des geometrischen Nivellements\n",
"pfad_datei_nivellement = r\"Daten\\Niv_bereinigt.DAT.csv\"\n",
"\n",
"# InstrumentenID des Nivelliers (siehe Zelle 4)\n",
"instrumentenID_Nivellier = 3\n",
"\n",
"# Datenvorverarbeitung und Import in die Datenbank ausführen\n",
"dict_punkthoehen_naeherung_niv, liste_punkte_in_db = imp.vorbereitung_import_beobachtungen_nivellement_naeherung_punkthoehen(pfad_datei_nivellement, instrumentenID_Nivellier)\n",
"imp.import_beobachtungen_nivellement_RVVR(pfad_datei_nivellement, instrumentenID_Nivellier)"
],
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Folgende Stand- und Zielpunkte des geometrischen Nivellements werden für die Beobachtungsgruppe ausgeglichen: ['812', '10047', '10046', '10045', '10034', 'FH14', 'FH11', '10035', '10029', '10030', '10031', '10017', '10013', '10012', '10014', '10015', '10016', '10007', 'FH13', '666', '10054', '10056', '10058', '10052', '10043', '10026', '10010', '10006', '816', '10048', 'FH3', '10049', '10053', '10050', '10051', 'FH4', '10040', '10037', '10038', '10039', '10032', 'FH15', '10033', '10025', '10024', '10023', '10022', '10021', '10020', '10019', '10036', '10028', '10011', '10001', '10003', '10008', '10005', '10004', '10002', '10055', '10057', '10059', '10044', '10041', '10042', '10027', '10018', '10009']\n",
"Für folgende Punkte wird aktuell keine Höhe in der Ausgleichung berechnet: ['80001', '80002', '90001', '90002', '90003', '90004', '90005', '90006', '90007', '90008', '90009', '90010', '90011', '90012', '90013', '90014', '70001', '70002', '60001', 'FH5', '60002', '60003', '60004', '60005', '60006', '60007', '60008', '60009', '60010', '30001', '30002', '30003', '30004', '30005', '30006', '30007', '30008']. Bei Bedarf im folgenden Schritt ändern!\n"
]
},
{
"data": {
"text/plain": [
"'Die Beobachtungen aus der Datei Daten\\\\Niv_bereinigt.DAT.csv wurden erfolgreich importiert.'"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"execution_count": 13
},
{
"metadata": {
"jupyter": {
"is_executing": true
},
"ExecuteTime": {
"start_time": "2026-02-05T12:24:17.017690Z"
}
},
"cell_type": "code",
"source": [
"# Zelle 14: Parameterschätzung iterativ berechnen\n",
"# Hinweis: Die Ausführung dauert je nach Rechenkapazität zwischen 13 und 20 Minuten.\n",
"\n",
"# Berechnung durchführen\n",
"A_matrix_numerisch, Jacobimatrix_symbolisch_liste_unbekannte, Jacobimatrix_symbolisch_liste_beobachtungsvektor, x, dx, dl_k, ausgabe_parameterschaetzung = iterat.iterationen(datumfestlegung, speichern_in_csv)\n",
"\n",
"# Koordinaten der letzten Iteration speichern\n",
"dict_koordinaten_ausgleichungsergebnis = fm.unbekanntenvektor_numerisch_to_dict_unbekanntenvektor(Jacobimatrix_symbolisch_liste_unbekannte, x)"
],
"id": "7d025ca293d73188",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Zelle 15: Proben\n",
"\n",
"# Rechenprobe (ATPV-Probe)\n",
"Proben.atpv_probe(A_matrix_numerisch, ausgabe_parameterschaetzung[\"P\"], ausgabe_parameterschaetzung[\"v\"])\n",
"\n",
"# Hauptprobe\n",
"Proben.hauptprobe(A_matrix_numerisch, dx, dl_k, ausgabe_parameterschaetzung[\"v\"])"
],
"id": "de8f624059005fdd",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": "# ------------------------------- Netzqualitätsmaße -------------------------------",
"id": "7d53274224166103",
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "84075bea1f2c44d7",
"metadata": {},
"source": [
"# Zelle 16: Gesamtredundanz r\n",
"\n",
"r_gesamt = Netzqualitaet_Zuverlaessigkeit.Zuverlaessigkeit.gesamtredundanz(A_matrix_numerisch.shape[0], A_matrix_numerisch.shape[1])"
],
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "1797726c5b3af9bf",
"metadata": {},
"source": [
"# Zelle 17: s0 a posteriori\n",
"\n",
"s0_aposteriori = Netzqualitaet_Genauigkeit.Genauigkeitsmaße.berechne_s0apost(ausgabe_parameterschaetzung[\"v\"], ausgabe_parameterschaetzung[\"P\"], r_gesamt)"
],
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "a2fe23d9a19ac2f9",
"metadata": {},
"source": [
"# Zelle 18: Redundanzanteile ri\n",
"\n",
"R, ri, EVi, Redundanzanteile = Netzqualitaet_Zuverlaessigkeit.Zuverlaessigkeit.redundanzanteile_ri(ausgabe_parameterschaetzung[\"Q_vv\"], ausgabe_parameterschaetzung[\"P\"], Jacobimatrix_symbolisch_liste_beobachtungsvektor)"
],
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "14db90a3d4d9118b",
"metadata": {},
"source": [
"# Zelle 19: Globaltest des Ausgleichungsmodells\n",
"\n",
"globaltest = Netzqualitaet_Zuverlaessigkeit.Zuverlaessigkeit.globaltest(r_gesamt=r_gesamt, sigma0_apost=s0_aposteriori, sigma0_apriori=1)"
],
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "1a84fbfb3db101c9",
"metadata": {},
"source": [
"# Zelle 20: Lokaltest und innere Zuverlässigkeit\n",
"# Bei der Auswahl einer GNSS-Komponente, wie z.B. bx werden automatisch die anderen beiden Kompontenen aus-, bzw. abgewählt. Bitte warten, bis dies automatisch durchführt wurde.\n",
"\n",
"lokaltest, beta = Netzqualitaet_Zuverlaessigkeit.Zuverlaessigkeit.aufruf_lokaltest(Jacobimatrix_symbolisch_liste_beobachtungsvektor, globaltest[\"alpha\"], ausgabe_parameterschaetzung, ri, s0_aposteriori)\n"
],
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "ebf2c9ef0a1899dc",
"metadata": {},
"source": [
"# Zelle 21: Ausgewählte Beobachtungen für weitere Iterationen ausschalten\n",
"\n",
"db_zugriff.set_beobachtung_ausschalten(lokaltest)"
],
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Zelle 22: Varianzkomponentenschätzung\n",
"\n",
"vks.varianzkomponten_berechnen(Jacobimatrix_symbolisch_liste_beobachtungsvektor, ausgabe_parameterschaetzung, R)"
],
"id": "dd7bfa4df762a4a7",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Zelle 23: Varianzkomponten anpassen\n",
"\n",
"vks.vks_ausfuehren()\n",
"vks.zeige_vks_tabelle()"
],
"id": "edb14958ee00130c",
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "256f4a0805b69e14",
"metadata": {},
"source": [
"# Zelle 24: Äußere Zuverlässigkeit\n",
"importlib.reload(Netzqualitaet_Zuverlaessigkeit)\n",
"\n",
"bezeichnungen = [str(s) for s in Jacobimatrix_symbolisch_liste_beobachtungsvektor]\n",
"\n",
"bezeichnungen = [str(s) for s in Jacobimatrix_symbolisch_liste_beobachtungsvektor]\n",
"\n",
"lokaltest_ergebnisse = Netzqualitaet_Zuverlaessigkeit.Zuverlaessigkeit.lokaltest_innere_Zuverlaessigkeit(\n",
" ausgabe_parameterschaetzung[\"v\"],\n",
" ausgabe_parameterschaetzung[\"Q_vv\"],\n",
" ri,\n",
" bezeichnungen,\n",
" s0_aposteriori,\n",
" globaltest[\"alpha\"],\n",
" beta\n",
")\n",
"\n",
"Aussen = Netzqualitaet_Zuverlaessigkeit.Zuverlaessigkeit.aeussere_zuverlaessigkeit(\n",
" Lokaltest=lokaltest_ergebnisse,\n",
" bezeichnung=bezeichnungen,\n",
" Qxx=ausgabe_parameterschaetzung[\"Q_xx\"],\n",
" A=A_matrix_numerisch,\n",
" P=ausgabe_parameterschaetzung[\"P\"],\n",
" s0_apost=s0_aposteriori,\n",
" unbekannten_liste=Jacobimatrix_symbolisch_liste_unbekannte,\n",
" x=x,\n",
" ausschliessen=\"lA\"\n",
")\n",
"\n",
"display(HTML(Aussen.to_html(index=False)))\n",
"Aussen.to_excel(r\"Zwischenergebnisse\\Aeussere_Zuverlaessigkeit.xlsx\", index=False)"
],
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Zelle 25: Standardabweichungen der einzelnen Punkte und Helmert'scher Punktfehler (3D)\n",
"\n",
"Helmertscher_Punktfehler = Netzqualitaet_Genauigkeit.Genauigkeitsmaße.helmert_punktfehler(ausgabe_parameterschaetzung[\"Q_xx\"], s0_aposteriori,Jacobimatrix_symbolisch_liste_unbekannte)"
],
"id": "9e6624251a23847d",
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "89fbcfe85fb6e4bb",
"metadata": {},
"source": [
"# Zelle 26: Standardellipse bzw. Helmert'sche Fehlerellipsen\n",
"\n",
"Standardellipse = Netzqualitaet_Genauigkeit.Genauigkeitsmaße.standardellipse(ausgabe_parameterschaetzung[\"Q_xx\"], s0_aposteriori, Jacobimatrix_symbolisch_liste_unbekannte)\n"
],
"outputs": [],
"execution_count": null
},
{
"cell_type": "code",
"id": "7de561d7eaebb1c2",
"metadata": {},
"source": [
"# Zelle 27: Konfidenzellipsen\n",
"\n",
"Konfidenzellipse = Netzqualitaet_Genauigkeit.Genauigkeitsmaße.konfidenzellipse(ausgabe_parameterschaetzung[\"Q_xx\"], s0_aposteriori, Jacobimatrix_symbolisch_liste_unbekannte, r_gesamt, False)"
],
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Zelle 28: Konfidenzellipsen im ENU-System\n",
"\n",
"Konfidenzellipse_ENU, R0 = Netzqualitaet_Genauigkeit.Genauigkeitsmaße.konfidenzellipsen_enu(a, b, ausgabe_parameterschaetzung, Jacobimatrix_symbolisch_liste_unbekannte, dict_koordinaten_ausgleichungsergebnis, s0_aposteriori, r_gesamt)"
],
"id": "ddc157c0ff21c93e",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# Zelle 29: Netzplot mit Konfidenzellipsen (im ENU-System)\n",
"\n",
"Koord_ENU = Berechnungen.ENU.transform_Koord_zu_KoordENU(dict_koordinaten_ausgleichungsergebnis, R0)\n",
"\n",
"Netzqualitaet_Genauigkeit.Plot.netzplot_ellipsen(\n",
" Koord_ENU=Koord_ENU,\n",
" unbekannten_labels=Jacobimatrix_symbolisch_liste_unbekannte,\n",
" beobachtungs_labels=Jacobimatrix_symbolisch_liste_beobachtungsvektor,\n",
" df_konf_ellipsen_enu=Konfidenzellipse_ENU,\n",
" skalierung=1000\n",
")"
],
"id": "94a42bd0a62875ea",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"from Koordinatentransformationen import Transformationen\n",
"trafos = Transformationen(pfad_datenbank)\n",
"\n",
"dict_koordinaten_utm = trafos.ecef_to_utm(\n",
" dict_koordinaten_ausgleichungsergebnis,\n",
" pfad_tif_quasigeoidundolation)\n",
"koordinaten_utm = (dict_koordinaten_utm)\n",
"print(koordinaten_utm)"
],
"id": "844b818e7a3db233",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"# 1. Wir nutzen dein existierendes 'dict_koordinaten'\n",
"# Da stehen nur die echten Punkte drin (74 Stück)\n",
"namen = list(dict_koordinaten_ausgleichungsergebnis.keys())\n",
"\n",
"# Die SymPy-Matrizen aus dem Dictionary in flache Listen umwandeln\n",
"koordinaten_liste = []\n",
"for k in namen:\n",
" matrix_werte = dict_koordinaten_ausgleichungsergebnis[k]\n",
" # Umwandlung von SymPy Matrix zu einfachen Floats\n",
" koordinaten_liste.append([float(matrix_werte[0]), float(matrix_werte[1]), float(matrix_werte[2])])\n",
"\n",
"# 2. DataFrame direkt aus der gefilterten Liste erstellen\n",
"# Hier passen index (74) und Daten (74 Zeilen) nun perfekt zusammen!\n",
"df_x_final = pd.DataFrame(koordinaten_liste, columns=['X [m]', 'Y [m]', 'Z [m]'], index=namen)\n",
"df_x_final.index.name = 'Punktnummer'\n",
"\n",
"# 3. UTM-Daten aufbereiten (wie gehabt)\n",
"# Wir stellen sicher, dass wir die Werte aus koordinaten_utm flachklopfen\n",
"utm_flach = {k: np.array(v).flatten().tolist() for k, v in koordinaten_utm.items()}\n",
"df_utm_final = pd.DataFrame.from_dict(utm_flach, orient='index', columns=['Rechtswert [m]', 'Hochwert [m]', 'Höhe [m]'])\n",
"df_utm_final.index.name = 'Punktnummer'\n",
"\n",
"# 4. Zahlenformatierung (Wissenschaftliche Notation unterdrücken)\n",
"df_x_final = df_x_final.map(lambda val: f\"{val:.4f}\")\n",
"df_utm_final = df_utm_final.map(lambda val: f\"{val:.4f}\")\n",
"\n",
"# 5. Export-Dictionary\n",
"ergebnisse = {\n",
" \"df_globaltest\": globaltest,\n",
" \"df_redundanz\": Redundanzanteile,\n",
" \"df_ellipsen\": Standardellipse,\n",
" \"df_konfidenzellipsen\": Konfidenzellipse,\n",
" \"df_koordinaten_geozentrisch_kartesisch\": df_x_final,\n",
" \"df_koordinaten_utm\": df_utm_final\n",
"}\n",
"\n",
"# Für die geozentrischen Koordinaten\n",
"df_x_final.index.name = 'Punktnummer'\n",
"\n",
"# Für die UTM-Koordinaten\n",
"df_utm_final.index.name = 'Punktnummer'"
],
"id": "343b70a659e335f8",
"outputs": [],
"execution_count": null
},
{
"metadata": {},
"cell_type": "code",
"source": [
"importlib.reload(Export)\n",
"# Zelle XX: Erzeugung eines Protokolls der hybriden Netzausgleichung\n",
"\n",
"# Input (später: an den Anfang des Notebooks schieben)\n",
"bearbeiter = input(\"Bearbeiter: \")\n",
"projekt = input(\"Projektname: \")\n",
"\n",
"metadaten = {\n",
" \"bearbeiter\": bearbeiter,\n",
" \"projekt\": projekt,\n",
" \"datum\": datetime.now().strftime(\"%d.%m.%Y\")\n",
"}\n",
"\n",
"\n",
"ergebnisse = {\n",
" \"df_globaltest\": globaltest,\n",
" \"df_redundanz\": Redundanzanteile,\n",
" \"df_ellipsen\": Standardellipse,\n",
" \"df_konfidenzellipsen\": Konfidenzellipse,\n",
" \"df_koordinaten_geozentrisch_kartesisch\": df_x_final,\n",
" \"df_koordinaten_utm\": df_utm_final\n",
"\n",
"}\n",
"\n",
"Export.Export.speichere_html_protokoll(metadaten, ergebnisse)"
],
"id": "23aa13721f563c90",
"outputs": [],
"execution_count": null
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.14.0"
}
},
"nbformat": 4,
"nbformat_minor": 5
}

59309
Campusnetz.ipynb
View File

File diff suppressed because it is too large Load Diff

2
Datenbank.py
View File

@@ -464,7 +464,7 @@ class Datenbankzugriff:
cursor.close()
con.close()
def set_normalhoehe_hfp(self, liste_normalhoehe_hfp: list) -> LiteralString | str:
def set_normalhoehe_hfp(self, liste_normalhoehe_hfp: list) -> str:
"""Speichert Normalhöhen von amtlichen Höhenfestpunkten (HFP) in Netzpunkte.
Existiert die Punktnummer bereits in der Tabelle Netzpunkte, wird das Attribut normalhoehe_hfp aktualisiert.

1
Export.py
View File

@@ -2,6 +2,7 @@ import csv
from datetime import datetime
import numpy as np
import os
import sympy as sp
import webbrowser
class Export:

8
Funktionales_Modell.py
View File

@@ -754,7 +754,7 @@ class FunktionalesModell:
"Unbekanntenvektor")
return unbekanntenvektor_numerisch
def unbekanntenvektor_numerisch_to_dict_unbekanntenvektor(self, liste_unbekanntenvektor_symbolisch: list, unbekanntenvektor_numerisch: np.Matrix) -> dict:
def unbekanntenvektor_numerisch_to_dict_unbekanntenvektor(self, liste_unbekanntenvektor_symbolisch: list, unbekanntenvektor_numerisch: np.asarray) -> dict:
"""Wandelt einen numerischen Unbekanntenvektor in ein Koordinatendictionary um.
Aus dem numerischen Unbekanntenvektor werden für alle Punkte die Koordinaten (X, Y, Z) extrahiert
@@ -763,7 +763,7 @@ class FunktionalesModell:
:param liste_unbekanntenvektor_symbolisch: Liste der Unbekannten (Symbole) in der Reihenfolge des numerischen Vektors.
:type liste_unbekanntenvektor_symbolisch: list
:param unbekanntenvektor_numerisch: Numerischer Unbekanntenvektor.
:type unbekanntenvektor_numerisch: np.Matrix
:type unbekanntenvektor_numerisch: np.asarray
:return: Dictionary {punktnummer: sp.Matrix([X, Y, Z])}.
:rtype: dict
"""
@@ -796,7 +796,7 @@ class FunktionalesModell:
return dict_koordinaten
def berechnung_dl(self, beobachtungsvektor_numerisch: np.Matrix, beobachtungsvektor_naeherung_numerisch: sp.Matrix,
def berechnung_dl(self, beobachtungsvektor_numerisch: np.asarray, beobachtungsvektor_naeherung_numerisch: sp.Matrix,
liste_beobachtungsvektor_symbolisch: list = None, iterationsnummer: int = 0) -> np.asarray:
"""Berechnet den Verbesserungsvektor dl = l − f(x0).
@@ -806,7 +806,7 @@ class FunktionalesModell:
Der Vektor dl wird als CSV-Datei in den Ordner Zwischenergebnisse exportiert.
:param beobachtungsvektor_numerisch: Numerischer Beobachtungsvektor l.
:type beobachtungsvektor_numerisch: np.Matrix
:type beobachtungsvektor_numerisch: np.asarray
:param beobachtungsvektor_naeherung_numerisch: Numerischer Näherungs-Beobachtungsvektor f(x0).
:type beobachtungsvektor_naeherung_numerisch: sp.Matrix
:param liste_beobachtungsvektor_symbolisch: Optional: Liste der Beobachtungskennungen.

4
Netzqualitaet_Genauigkeit.py
View File

@@ -3,7 +3,7 @@ import plotly.graph_objects as go
from scipy.stats import f
import pandas as pd
from IPython.display import HTML
from IPython.display import display, clear_output
from IPython.display import display
import Berechnungen
import Einheitenumrechnung
@@ -359,7 +359,7 @@ class Genauigkeitsmaße:
)
print(
f"ENU-Referenz (Schwerpunkt): B0={Einheitenumrechnung.rad_to_gon_Decimal(B0):.8f} rad, L0={Einheitenumrechnung.rad_to_gon_Decimal(L0):.8f} rad")
f"ENU-Referenz (Schwerpunkt): B0={Einheitenumrechnung.Einheitenumrechnung.rad_to_gon_Decimal(B0):.8f} rad, L0={Einheitenumrechnung.Einheitenumrechnung.rad_to_gon_Decimal(L0):.8f} rad")
# 2) Konfidenzellipse im ENU-System
Konfidenzellipse_ENU, alpha = Genauigkeitsmaße.konfidenzellipse(

2
Parameterschaetzung.py
View File

@@ -1,11 +1,9 @@
from Stochastisches_Modell import StochastischesModell
from Datumsfestlegung import Datumsfestlegung
import Datenbank
from Export import Export as Exporter
import Stochastisches_Modell
import Funktionales_Modell
import Parameterschaetzung
import Datumsfestlegung
import numpy as np

12
Stochastisches_Modell.py
View File

@@ -118,6 +118,8 @@ class StochastischesModell:
for j in range(i + 1, len(liste_beobachtungen_symbolisch)):
beobachtung_symbolisch_j = liste_beobachtungen_symbolisch[j]
aufgeteilt_j = beobachtung_symbolisch_j.split("_")
if len(aufgeteilt_j) < 2:
continue
beobachtungsart_j = str(aufgeteilt_j[1])
if beobachtungsart_i == "SD" and beobachtungsart_j == "SD":
@@ -203,7 +205,7 @@ class StochastischesModell:
Export.matrix_to_csv(r"Zwischenergebnisse\Qll_Symbolisch.csv", liste_beobachtungen_symbolisch, liste_beobachtungen_symbolisch, Qll, "Qll")
return Qll
def Qll_numerisch(self, Qll_Matrix_Symbolisch: sp.Matrix, liste_beobachtungen_symbolisch: list) -> np.Matrix:
def Qll_numerisch(self, Qll_Matrix_Symbolisch: sp.Matrix, liste_beobachtungen_symbolisch: list) -> np.asarray:
"""Erstellt eine numerische Kofaktormatrix der Beobachtungen aus einer symbolischen Qll-Matrix.
Es werden die zur Substitution benötigten Werte aus der Datenbank abgefragt und den in Qll vorkommenden Symbolen zugeordnet,
@@ -226,7 +228,7 @@ class StochastischesModell:
:param liste_beobachtungen_symbolisch: Liste der symbolischen Beobachtungskennungen.
:type liste_beobachtungen_symbolisch: list
:return: Numerische Kofaktormatrix Qll als Numpy-Array.
:rtype: np.Matrix
:rtype: np.asarray
:raises ValueError: Falls Symbole in Qll_Matrix_Symbolisch enthalten sind, für die keine Substitutionen vorhanden sind.
"""
liste_beobachtungen_symbolisch = [str(b).strip() for b in liste_beobachtungen_symbolisch]
@@ -379,7 +381,7 @@ class StochastischesModell:
return Qll_numerisch
def QAA_symbolisch(self, liste_beobachtungen_symbolisch: list) -> np.Matrix:
def QAA_symbolisch(self, liste_beobachtungen_symbolisch: list) -> np.asarray:
"""Erstellt die symbolische Kofaktormatrix der Anschlusspunkte (weiche Lagerung).
Es werden ausschließlich Beobachtungen berücksichtigt, deren Kennung mit "lA_" beginnt. Für jede Anschlussbedingung
@@ -419,7 +421,7 @@ class StochastischesModell:
Export.matrix_to_csv(r"Zwischenergebnisse\QAA_Symbolisch.csv", liste_beobachtungen_symbolisch, liste_beobachtungen_symbolisch, Qll, "Qll")
return Qll
def QAA_numerisch(self, QAA_Matrix_Symbolisch: sp.Matrix, liste_beobachtungen_symbolisch: list) -> np.Matrix:
def QAA_numerisch(self, QAA_Matrix_Symbolisch: sp.Matrix, liste_beobachtungen_symbolisch: list) -> np.asarray:
"""Erstellt eine numerische Matrix aus einer symbolischen QAA-Matrix.
Es werden die numerischen Standardabweichungen der Anschlussbedingungen sowie die Varianzkomponente der Gruppe
@@ -433,7 +435,7 @@ class StochastischesModell:
:param liste_beobachtungen_symbolisch: Liste der symbolischen Beobachtungskennungen.
:type liste_beobachtungen_symbolisch: list
:return: Numerische VKofaktormatrix QAA als Numpy-Array.
:rtype: np.Matrix
:rtype: np.asarray
"""
# Symbolische Listen
liste_beobachtungen_symbolisch = [str(b).strip() for b in liste_beobachtungen_symbolisch]