zusammenfügen

Berechnungen.py

@@ -1,6 +1,8 @@
 import sympy as sp
 from decimal import Decimal
 import math
+import numpy as np
+import Datenbank
 
 class Berechnungen:
     def __init__(self, a, b):
@@ -16,31 +18,130 @@ class Berechnungen:
         return (self.a_wert**2 - self.b_wert**2) / self.b_wert **2
 
     def P(self, x, y):
-        return sp.sqrt(x**2 + y**2)
+        return np.sqrt(x**2 + y**2)
 
-    def hilfswinkel(self, z, x, y):
+    def hilfswinkel(self, x, y, z):
-        hw = sp.atan2(z * self.a_wert, self.P(x, y) * self.b_wert)
+        hw = np.atan2(z * self.a_wert, self.P(x, y) * self.b_wert)
         return hw
 
-    def B(self, z, x, y):
+    def B(self, x, y, z):
-        hilfswinkel = self.hilfswinkel(z, x, y)
+        hilfswinkel = self.hilfswinkel(x, y, z)
-        B = sp.atan2((z + self.e_strich_quadrat_wert * self.b_wert * sp.sin(hilfswinkel) ** 3), (self.P(x, y) - self.e_quadrat_wert * self.a_wert * sp.cos(hilfswinkel) ** 3))
+        B = np.atan2((z + self.e_strich_quadrat_wert * self.b_wert * np.sin(hilfswinkel) ** 3), (self.P(x, y) - self.e_quadrat_wert * self.a_wert * np.cos(hilfswinkel) ** 3))
         return B
 
     def L(self, x, y):
-        return sp.atan2(y, x)
+        return np.atan2(y, x)
 
     def H(self, x, y, z):
-        B = self.B(z, x, y)
+        B = self.B(x, y, z)
-        H = (self.P(x, y) / sp.cos(B)) - self.a_wert / (sp.sqrt(1 - self.e_quadrat_wert * sp.sin(B) ** 2))
+        H = (self.P(x, y) / np.cos(B)) - self.a_wert / (np.sqrt(1 - self.e_quadrat_wert * np.sin(B) ** 2))
         return H
 
+    def E(self, L, dX, dY):
+        E = -np.sin(L) * dX + np.cos(L) * dY
+        return E
+
+    def N(self, B, L, dX, dY, dZ):
+        N = -np.sin(B) * np.cos(L) * dX - np.sin(B) * np.sin(L) * dY + np.cos(B) * dZ
+        return N
+
+    def U(self, B, L, dX, dY, dZ):
+        U = np.cos(B) * np.cos(L) * dX + np.cos(B) * np.sin(L) *dY + np.sin(B) * dZ
+        return U
+
+    def horizontalstrecke_ENU(self, E, N):
+        s = np.sqrt(E**2 + N**2)
+        return s
+
+    def Zenitwinkel(self, horizontalstrecke_ENU, U):
+        zw = np.atan2(horizontalstrecke_ENU, U)
+        return zw
+
+    def Azimut(self, E, N):
+        Azimut = np.atan2(E, N)
+        if Azimut < 0:
+            Azimut += 2 * np.pi
+        if Azimut > 2 * np.pi:
+            Azimut -= 2 * np.pi
+        return Azimut
+
+    def Richtung(self, Azimut, Orientierung):
+        Richtung = Azimut - Orientierung
+        if Richtung < 0:
+            Richtung += 2 * np.pi
+        if Richtung > 2 * np.pi:
+            Richtung -= 2 * np.pi
+        return Richtung
+
     def geometrische_breite_laenge(self, dict_koordinaten):
         for punktnummer, matrix in dict_koordinaten.items():
 
-            dict_koordinaten[punktnummer] = [matrix, self.B(matrix[2], matrix[0], matrix[1]), self.L(matrix[0], matrix[1])]
+            dict_koordinaten[punktnummer] = [matrix, self.B(matrix[0], matrix[1], matrix[2]), self.L(matrix[0], matrix[1])]
         return dict_koordinaten
 
+    def berechnung_richtung_azimut_zenitwinkel(self, pfad_datenbank, dict_koordinaten):
+        dict_koordinaten_erweitert = {}
+        dict_orientierungen = {}
+        liste_azimut_richtungen = []
+        db_zugriff = Datenbank.Datenbankzugriff(pfad_datenbank)
+        liste_beobachtungen_tachymeter = db_zugriff.get_beobachtungen_from_beobachtungenid()
+
+        for punktnummer, koordinaten in dict_koordinaten.items():
+            X = float(koordinaten[0])
+            Y = float(koordinaten[1])
+            Z = float(koordinaten[2])
+
+            P = self.P(X, Y)
+            hilfwinkel = self.hilfswinkel(X, Y, Z)
+            B = self.B(X, Y, Z)
+            L = self.L(X, Y)
+            H = self.H(X, Y, Z)
+
+            dict_koordinaten_erweitert[punktnummer] = koordinaten, P, hilfwinkel, B, L, H
+
+        beobachtsgruppeID_vorher = None
+        for beobachtung_tachymeter in liste_beobachtungen_tachymeter:
+            standpunkt = beobachtung_tachymeter[0]
+            zielpunkt = beobachtung_tachymeter[1]
+
+            X1 = dict_koordinaten[beobachtung_tachymeter[0]][0]
+            X2 = dict_koordinaten[beobachtung_tachymeter[1]][0]
+            Y1 = dict_koordinaten[beobachtung_tachymeter[0]][1]
+            Y2 = dict_koordinaten[beobachtung_tachymeter[1]][1]
+            Z1 = dict_koordinaten[beobachtung_tachymeter[0]][2]
+            Z2 = dict_koordinaten[beobachtung_tachymeter[1]][2]
+
+            dX = float(X2 - X1)
+            dY = float(Y2 - Y1)
+            dZ = float(Z2 - Z1)
+
+            B = float(dict_koordinaten_erweitert[beobachtung_tachymeter[0]][3])
+            L = float(dict_koordinaten_erweitert[beobachtung_tachymeter[0]][4])
+
+            E = self.E(L, dX, dY)
+            N = self.N(B, L, dX, dY, dZ)
+            U = self.U(B, L, dX, dY, dZ)
+
+            horizontalstrecke_ENU = self.horizontalstrecke_ENU(E, N)
+            Azimut = float(self.Azimut(E, N))
+            Zenitwinkel = float(self.Zenitwinkel(horizontalstrecke_ENU, U))
+
+            beobachtsgruppeID_aktuell = beobachtung_tachymeter[3]
+            if beobachtsgruppeID_aktuell == beobachtsgruppeID_vorher:
+                richtung = float(self.Richtung(Azimut, orientierung))
+                liste_azimut_richtungen.append((standpunkt, zielpunkt, Azimut, richtung, Zenitwinkel))
+
+            else:
+                orientierung = Azimut
+                dict_orientierungen[beobachtsgruppeID_aktuell] = orientierung
+
+                richtung = float(self.Richtung(Azimut, orientierung))
+                liste_azimut_richtungen.append((standpunkt, zielpunkt, Azimut, richtung, Zenitwinkel))
+
+            beobachtsgruppeID_vorher = beobachtsgruppeID_aktuell
+        return liste_azimut_richtungen, dict_orientierungen
+
+
 class Einheitenumrechnung:
     def __init__(self):
         pass

Datenbank.py

@@ -47,16 +47,13 @@ class Datenbank_anlegen:
                                     gnss_bx NUMERIC(7, 4),
                                     gnss_by NUMERIC(7, 4),
                                     gnss_bz NUMERIC(7, 4),
-                                    gnss_m0                          NUMERIC(1, 8),
+                                    gnss_s0                          NUMERIC(1, 8),
-                                    gnss_q11                          NUMERIC(1, 8),
+                                    gnss_cxx                          NUMERIC(1, 8),
-                                    gnss_q12                          NUMERIC(1, 8),
+                                    gnss_cxy                          NUMERIC(1, 8),
-                                    gnss_q13                          NUMERIC(1, 8),
+                                    gnss_cxz                          NUMERIC(1, 8),
-                                    gnss_q21                          NUMERIC(1, 8),
+                                    gnss_cyy                          NUMERIC(1, 8),
-                                    gnss_q22                          NUMERIC(1, 8),
+                                    gnss_cyz                          NUMERIC(1, 8),
-                                    gnss_q23                          NUMERIC(1, 8),
+                                    gnss_czz                          NUMERIC(1, 8),
-                                    gnss_q31                          NUMERIC(1, 8),
-                                    gnss_q32                          NUMERIC(1, 8),
-                                    gnss_q33                          NUMERIC(1, 8),
                                     niv_dh                            NUMERIC(8, 6),
                                     niv_strecke                       NUMERIC(8, 6),
                                     niv_anz_standpkte                 INTEGER,
@@ -92,34 +89,6 @@ class Datenbankzugriff:
     def __init__(self, pfad_datenbank):
         self.pfad_datenbank = pfad_datenbank
 
-    def get_koordinaten(self, koordinatenart, ausgabeart = "Dict"):
-        con = sqlite3.connect(self.pfad_datenbank)
-        cursor = con.cursor()
-        if koordinatenart == "naeherung_lh":
-            values = "punktnummer, naeherungx_lh, naeherungy_lh, naeherungz_lh"
-        elif koordinatenart == "naeherung_us":
-            values = "punktnummer, naeherungx_us, naeherungy_us, naeherungz_us"
-
-        liste_koordinaten = cursor.execute(f"""
-        SELECT {values} FROM Netzpunkte;
-        """).fetchall()
-        cursor.close()
-        con.close()
-
-        liste_koordinaten = [
-            koordinate for koordinate in liste_koordinaten
-            if koordinate[1] is not None and koordinate[2] is not None and koordinate[3] is not None
-        ]
-        if ausgabeart == "Dict":
-            return {
-                koordinate[0]: sp.Matrix([
-                    sp.Float(str(koordinate[1])),
-                    sp.Float(str(koordinate[2])),
-                    sp.Float(str(koordinate[3]))
-                ])
-                for koordinate in liste_koordinaten
-            }
-
     def set_koordinaten(self, dict_koordinaten, koordinatenart):
         con = sqlite3.connect(self.pfad_datenbank)
         cursor = con.cursor()
@@ -351,6 +320,34 @@ class Datenbankzugriff:
         else:
             return f"Es wurden keine neuen Normalhöhen übergeben. Folgende Normalhöhen sind in der Datenbank enthalten: {liste_hfp_in_db}"
 
+    def get_koordinaten(self, koordinatenart, ausgabeart = "Dict"):
+        con = sqlite3.connect(self.pfad_datenbank)
+        cursor = con.cursor()
+        if koordinatenart == "naeherung_lh":
+            values = "punktnummer, naeherungx_lh, naeherungy_lh, naeherungz_lh"
+        elif koordinatenart == "naeherung_us":
+            values = "punktnummer, naeherungx_us, naeherungy_us, naeherungz_us"
+
+        liste_koordinaten = cursor.execute(f"""
+        SELECT {values} FROM Netzpunkte;
+        """).fetchall()
+        cursor.close()
+        con.close()
+
+        liste_koordinaten = [
+            koordinate for koordinate in liste_koordinaten
+            if koordinate[1] is not None and koordinate[2] is not None and koordinate[3] is not None
+        ]
+        if ausgabeart == "Dict":
+            return {
+                koordinate[0]: sp.Matrix([
+                    sp.Float(str(koordinate[1])),
+                    sp.Float(str(koordinate[2])),
+                    sp.Float(str(koordinate[3]))
+                ])
+                for koordinate in liste_koordinaten
+            }
+
     def get_normalhoehe_hfp(self):
         con = sqlite3.connect(self.pfad_datenbank)
         cursor = con.cursor()
@@ -404,8 +401,83 @@ class Datenbankzugriff:
     def get_beobachtungen_from_beobachtungenid(self):
         con = sqlite3.connect(self.pfad_datenbank)
         cursor = con.cursor()
-        liste_beobachtungen = cursor.execute(f"SELECT punktnummer_sp, punktnummer_zp, beobachtungenID, beobachtungsgruppeID, tachymeter_richtung, tachymeter_zenitwinkel, tachymeter_distanz FROM Beobachtungen").fetchall()
+        liste_beobachtungen = cursor.execute(f"SELECT punktnummer_sp, punktnummer_zp, beobachtungenID, beobachtungsgruppeID, tachymeter_richtung, tachymeter_zenitwinkel, tachymeter_distanz FROM Beobachtungen WHERE tachymeter_richtung IS NOT NULL").fetchall()
         cursor.close()
         con.close()
         return liste_beobachtungen
 
+    def get_beobachtungen_gnssbasislinien(self):
+        con = sqlite3.connect(self.pfad_datenbank)
+        cursor = con.cursor()
+        liste_beobachtungen = cursor.execute(f"SELECT beobachtungenID, punktnummer_sp, punktnummer_zp, gnss_bx, gnss_by, gnss_bz, gnss_s0, gnss_cxx, gnss_cxy, gnss_cxz, gnss_cyy, gnss_cyz, gnss_czz FROM Beobachtungen WHERE gnss_bx IS NOT NULL AND gnss_by IS NOT NULL AND gnss_bz IS NOT NULL AND gnss_s0 IS NOT NULL AND gnss_cxx IS NOT NULL AND gnss_cxy IS NOT NULL AND gnss_cxz IS NOT NULL AND gnss_cyy IS NOT NULL AND gnss_cyz IS NOT NULL AND gnss_czz IS NOT NULL").fetchall()
+        cursor.close()
+        con.close()
+        return liste_beobachtungen
+
+    def get_datumskoordinate(self):
+        con = sqlite3.connect(self.pfad_datenbank)
+        cursor = con.cursor()
+        liste_datumskoordinate_x = cursor.execute(
+            f"SELECT punktnummer FROM Netzpunkte WHERE datumskoordinate_x = 1").fetchall()
+        liste_datumskoordinate_y = cursor.execute(
+            f"SELECT punktnummer FROM Netzpunkte WHERE datumskoordinate_y = 1").fetchall()
+        liste_datumskoordinate_z = cursor.execute(
+            f"SELECT punktnummer FROM Netzpunkte WHERE datumskoordinate_z = 1").fetchall()
+
+        cursor.close()
+        con.close()
+
+        liste_datumskoordinaten = []
+        if liste_datumskoordinate_x != []:
+            for datumskoordinate in liste_datumskoordinate_x:
+                datumskoordinate = str(datumskoordinate[0]).strip()
+                liste_datumskoordinaten.append(f"X{datumskoordinate}")
+        if liste_datumskoordinate_y != []:
+            for datumskoordinate in liste_datumskoordinate_y:
+                datumskoordinate = str(datumskoordinate[0]).strip()
+                liste_datumskoordinaten.append(f"Y{datumskoordinate}")
+        if liste_datumskoordinate_z != []:
+            for datumskoordinate in liste_datumskoordinate_z:
+                datumskoordinate = str(datumskoordinate[0]).strip()
+                liste_datumskoordinaten.append(f"Z{datumskoordinate}")
+
+        return liste_datumskoordinaten
+
+    def get_stabw_AA_Netzpunkte(self):
+        con = sqlite3.connect(self.pfad_datenbank)
+        cursor = con.cursor()
+        liste_stabwAA_x = cursor.execute(f"SELECT punktnummer, stabw_vorinfo_x FROM Netzpunkte WHERE stabw_vorinfo_x IS NOT NULL").fetchall()
+        liste_stabwAA_y = cursor.execute(
+            f"SELECT punktnummer, stabw_vorinfo_y FROM Netzpunkte WHERE stabw_vorinfo_y IS NOT NULL").fetchall()
+        liste_stabwAA_z = cursor.execute(
+            f"SELECT punktnummer, stabw_vorinfo_z FROM Netzpunkte WHERE stabw_vorinfo_z IS NOT NULL").fetchall()
+
+        cursor.close()
+        con.close()
+
+        dict_stabwAA = {}
+        for stabwAA_x in liste_stabwAA_x:
+            punktnummer = str(stabwAA_x[0]).strip()
+            wert = stabwAA_x[1]
+            dict_stabwAA[f"StabwAA_X{punktnummer}"]= wert
+
+        for stabwAA_y in liste_stabwAA_y:
+            punktnummer = str(stabwAA_y[0]).strip()
+            wert = stabwAA_y[1]
+            dict_stabwAA[f"StabwAA_Y{punktnummer}"]= wert
+
+        for stabwAA_z in liste_stabwAA_z:
+            punktnummer = str(stabwAA_z[0]).strip()
+            wert = stabwAA_z[1]
+            dict_stabwAA[f"StabwAA_Z{punktnummer}"]= wert
+
+        return dict_stabwAA
+
+    def get_gnss_beobachtungen_punktnummern(self):
+        con = sqlite3.connect(self.pfad_datenbank)
+        cursor = con.cursor()
+        liste_gnss_beobachtungen = cursor.execute(f"SELECT beobachtungenID, punktnummer_sp, punktnummer_zp FROM Beobachtungen WHERE gnss_bx IS NOT NULL AND gnss_by IS NOT NULL AND gnss_bz IS NOT NULL AND gnss_s0 IS NOT NULL AND gnss_cxx IS NOT NULL AND gnss_cxy IS NOT NULL AND gnss_cxz IS NOT NULL AND gnss_cyy IS NOT NULL AND gnss_cyz IS NOT NULL AND gnss_czz IS NOT NULL").fetchall()
+        cursor.close()
+        con.close()
+        return liste_gnss_beobachtungen
+

Datumsfestlegung.py

@@ -88,6 +88,7 @@ class Datumsfestlegung:
 
         return G
 
+
     @staticmethod
     def berechne_dx_geraendert(N: sp.Matrix, n: sp.Matrix, Gi: sp.Matrix) -> sp.Matrix:
         if N.rows != N.cols:
@@ -151,4 +152,4 @@ class Datumsfestlegung:
         Q_ext[:Q_ll.rows, :Q_ll.cols] = Q_ll
         Q_ext[Q_ll.rows:, Q_ll.cols:] = Sigma_AA
 
-        return A_ext, dl_ext, Q_ext
+        return A_ext, dl_ext, Q_ext

Funktionales_Modell.py

@@ -1,15 +1,18 @@
-from Datenbank import *
+from Datenbank import Datenbankzugriff
 import sympy as sp
 from Export import Export
 from Berechnungen import Berechnungen
 import numpy as np
+import importlib
 
 
 
 class FunktionalesModell:
     def __init__(self, pfad_datenbank, a, b):
         self.pfad_datenbank = pfad_datenbank
-        self.berechnungen = Berechnungen(a, b)
+        self.a = a
+        self.b = b
+        self.berechnungen = Berechnungen(self.a, self.b)
         self.substitutionen_dict = self.dict_substitutionen_uebergeordnetes_system()
         self.dict_punkt_symbole = {}
         self.liste_symbole_lambdify = sorted(self.substitutionen_dict.keys(), key=lambda s: str(s))
@@ -18,34 +21,55 @@ class FunktionalesModell:
         self.func_u0 = None
         self.liste_beobachtungsvektor_symbolisch = None
 
-    def jacobi_matrix_symbolisch(self):
+    def jacobi_matrix_symbolisch(self, datumsfestlegung = None, liste_unbekannte_datumsfestlegung = None):
-        liste_beobachtungsarten = ["tachymeter_distanz", "tachymeter_richtung", "tachymeter_zenitwinkel"]
+        #liste_beobachtungsarten = ["tachymeter_distanz", "tachymeter_richtung", "tachymeter_zenitwinkel"]
-        #liste_beobachtungsarten = ["tachymeter_distanz"]
+
+        liste_beobachtungsarten = ["tachymeter_distanz", "tachymeter_richtung", "tachymeter_zenitwinkel", "gnss_basislinien"]
         db_zugriff = Datenbankzugriff(self.pfad_datenbank)
 
-        liste_beobachtungen_rohdaten = []
+        liste_beobachtungen_rohdaten_gnssbasislinien = []
+        liste_beobachtungen_rohdaten_tachymeter = []
         liste_punktnummern =[]
 
         liste_orientierungsunbekannte = []
 
         for beobachtungsart in liste_beobachtungsarten:
-            liste_id_standpunkt_zielpunkt = db_zugriff.get_beobachtungen_id_beobachtungsgruppe_standpunkt_zielpunkt(beobachtungsart)
+            #Tachymeter Block
+            if beobachtungsart.startswith("tachymeter"):
+                liste_id_standpunkt_zielpunkt = db_zugriff.get_beobachtungen_id_beobachtungsgruppe_standpunkt_zielpunkt(beobachtungsart)
 
-            for beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt in liste_id_standpunkt_zielpunkt:
+                for beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt in liste_id_standpunkt_zielpunkt:
-                liste_beobachtungen_rohdaten.append(
+                    liste_beobachtungen_rohdaten_tachymeter.append(
-                    (beobachtungsart, beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt)
+                        (beobachtungsart, beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt)
-                )
+                    )
 
-                if standpunkt not in liste_punktnummern:
+                    if standpunkt not in liste_punktnummern:
-                    liste_punktnummern.append(standpunkt)
+                        liste_punktnummern.append(standpunkt)
-                if zielpunkt not in liste_punktnummern:
+                    if zielpunkt not in liste_punktnummern:
-                    liste_punktnummern.append(zielpunkt)
+                        liste_punktnummern.append(zielpunkt)
+
+                    if beobachtungsart == "tachymeter_richtung":
+                        if beobachtungsgruppeID not in liste_orientierungsunbekannte:
+                            liste_orientierungsunbekannte.append(beobachtungsgruppeID)
+            #GNSS Block
+            if beobachtungsart == "gnss_basislinien":
+                liste_id_standpunkt_zielpunkt = db_zugriff.get_gnss_beobachtungen_punktnummern()
+
+                for beobachtungenID, standpunkt, zielpunkt in liste_id_standpunkt_zielpunkt:
+                    standpunkt = str(standpunkt).strip()
+                    zielpunkt = str(zielpunkt).strip()
+                    liste_beobachtungen_rohdaten_gnssbasislinien.append((beobachtungsart, beobachtungenID, standpunkt, zielpunkt))
+
+                    if standpunkt not in liste_punktnummern:
+                        liste_punktnummern.append(standpunkt)
+                    if zielpunkt not in liste_punktnummern:
+                        liste_punktnummern.append(zielpunkt)
+
+
+
+        #if liste_beobachtungen_rohdaten_tachymeter == []:
+        #    return None
 
-                if beobachtungsart == "tachymeter_richtung":
-                    if beobachtungsgruppeID not in liste_orientierungsunbekannte:
-                        liste_orientierungsunbekannte.append(beobachtungsgruppeID)
-        if liste_beobachtungen_rohdaten == []:
-            return None
 
         #dict_punkt_symbole = {}
         liste_unbekannte = []
@@ -68,158 +92,181 @@ class FunktionalesModell:
 
         liste_A_richtung_zeilen = []
         liste_zeilenbeschriftungen_richtung = []
+
         liste_A_zenitwinkel_zeilen = []
         liste_zeilenbeschriftungen_zenitwinkel = []
 
+        liste_beobachtungsgleichungen_gnssbasislinien = []
+        liste_A_gnssbasislinien_zeilen = []
+        liste_zeilenbeschriftungen_gnssbasislinien = []
 
-        for beobachtungsart, beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt in liste_beobachtungen_rohdaten:
+        if liste_beobachtungen_rohdaten_tachymeter != []:
-            X_sp, Y_sp, Z_sp = self.dict_punkt_symbole[standpunkt]
+            for beobachtungsart, beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt in liste_beobachtungen_rohdaten_tachymeter:
-            X_zp, Y_zp, Z_zp = self.dict_punkt_symbole[zielpunkt]
+                X_sp, Y_sp, Z_sp = self.dict_punkt_symbole[standpunkt]
-            B_sp, L_sp = sp.symbols(f"B{standpunkt} L{standpunkt}")
+                X_zp, Y_zp, Z_zp = self.dict_punkt_symbole[zielpunkt]
+                B_sp, L_sp = sp.symbols(f"B{standpunkt} L{standpunkt}")
 
-            # Symbole für die Beobachtungswerte (werden später numerisch substituiert)
+                alpha = sp.symbols(f"{beobachtungenID}_R_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
-            alpha = sp.symbols(f"{beobachtungenID}_R_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
+                zw = sp.symbols(f"{beobachtungenID}_ZW_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
-            zw = sp.symbols(f"{beobachtungenID}_ZW_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
+                s = sp.symbols(f"{beobachtungenID}_SD_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
-            s = sp.symbols(f"{beobachtungenID}_SD_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
 
-            if beobachtungsart == "tachymeter_distanz":
+                if beobachtungsart == "tachymeter_distanz":
-                beobachtungsgleichung = sp.sqrt((X_zp - X_sp) ** 2 + (Y_zp - Y_sp) ** 2 + (Z_zp - Z_sp) ** 2)
+                    beobachtungsgleichung = sp.sqrt((X_zp - X_sp) ** 2 + (Y_zp - Y_sp) ** 2 + (Z_zp - Z_sp) ** 2)
-                liste_beobachtungsgleichungen_distanz.append(beobachtungsgleichung)
+                    liste_beobachtungsgleichungen_distanz.append(beobachtungsgleichung)
-                liste_zeilenbeschriftungen_distanz.append(
+                    liste_zeilenbeschriftungen_distanz.append(
-                    f"{beobachtungenID}_SD_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
+                        f"{beobachtungenID}_SD_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
 
 
 
-            elif beobachtungsart == "tachymeter_richtung":
+                elif beobachtungsart == "tachymeter_richtung":
 
-                # Richtung nach Otepka: r = a12 + O
+                    # Richtung nach Otepka: r = a12 + O
 
-                # dB und dL werden bewusst weggelassen
+                    # dB und dL werden bewusst weggelassen
 
-                dX = X_zp - X_sp
+                    dX = X_zp - X_sp
 
-                dY = Y_zp - Y_sp
+                    dY = Y_zp - Y_sp
 
-                dZ = Z_zp - Z_sp
+                    dZ = Z_zp - Z_sp
 
-                # Lokales System: x_loc = Nord, y_loc = Ost
+                    # Lokales System: x_loc = Nord, y_loc = Ost
 
-                x_loc = (-sp.sin(B_sp) * sp.cos(L_sp)) * dX + (-sp.sin(B_sp) * sp.sin(L_sp)) * dY + (sp.cos(B_sp)) * dZ
+                    x_loc = (-sp.sin(B_sp) * sp.cos(L_sp)) * dX + (-sp.sin(B_sp) * sp.sin(L_sp)) * dY + (sp.cos(B_sp)) * dZ
 
-                y_loc = (-sp.sin(L_sp)) * dX + (sp.cos(L_sp)) * dY
+                    y_loc = (-sp.sin(L_sp)) * dX + (sp.cos(L_sp)) * dY
 
-                # Otepka-Nenner: s12 * sin(zw12) = sqrt(x_loc^2 + y_loc^2)
+                    # Otepka-Nenner: s12 * sin(zw12) = sqrt(x_loc^2 + y_loc^2)
 
-                s_horiz = sp.sqrt(x_loc ** 2 + y_loc ** 2)
+                    s_horiz = sp.sqrt(x_loc ** 2 + y_loc ** 2)
 
-                # sin(t12), cos(t12) im Horizontsystem (t12 = Azimut, rechtsdrehend, Bezug Nord)
+                    # sin(t12), cos(t12) im Horizontsystem (t12 = Azimut, rechtsdrehend, Bezug Nord)
 
-                sin_t = y_loc / s_horiz
+                    sin_t = y_loc / s_horiz
 
-                cos_t = x_loc / s_horiz
+                    cos_t = x_loc / s_horiz
 
-                # Partielle Ableitungen nach Otepka (15) ohne dB und dL
+                    # Partielle Ableitungen nach Otepka (15) ohne dB und dL
 
-                d_r_dX_zp = (sp.sin(B_sp) * sp.cos(L_sp) * sin_t - sp.sin(L_sp) * cos_t) / s_horiz
+                    d_r_dX_zp = (sp.sin(B_sp) * sp.cos(L_sp) * sin_t - sp.sin(L_sp) * cos_t) / s_horiz
 
-                d_r_dY_zp = (sp.sin(B_sp) * sp.sin(L_sp) * sin_t + sp.cos(L_sp) * cos_t) / s_horiz
+                    d_r_dY_zp = (sp.sin(B_sp) * sp.sin(L_sp) * sin_t + sp.cos(L_sp) * cos_t) / s_horiz
 
-                d_r_dZ_zp = (-sp.cos(B_sp) * sin_t) / s_horiz
+                    d_r_dZ_zp = (-sp.cos(B_sp) * sin_t) / s_horiz
 
-                # Standpunkt-Ableitungen (SP) = negatives Vorzeichen
+                    # Standpunkt-Ableitungen (SP) = negatives Vorzeichen
 
-                d_r_dX_sp, d_r_dY_sp, d_r_dZ_sp = -d_r_dX_zp, -d_r_dY_zp, -d_r_dZ_zp
+                    d_r_dX_sp, d_r_dY_sp, d_r_dZ_sp = -d_r_dX_zp, -d_r_dY_zp, -d_r_dZ_zp
 
-                # Orientierung: r = a + O  =>  ∂r/∂O = -1
+                    # Orientierung: r = a + O  =>  ∂r/∂O = -1
 
-                d_r_dO_sp = -1
+                    d_r_dO_sp = -1
 
-                zeile_A_Matrix = []
+                    zeile_A_Matrix = []
 
-                for punkt in liste_punktnummern:
+                    for punkt in liste_punktnummern:
 
-                    if punkt == standpunkt:
+                        if punkt == standpunkt:
 
-                        zeile_A_Matrix.extend([d_r_dX_sp, d_r_dY_sp, d_r_dZ_sp])
+                            zeile_A_Matrix.extend([d_r_dX_sp, d_r_dY_sp, d_r_dZ_sp])
 
-                    elif punkt == zielpunkt:
+                        elif punkt == zielpunkt:
 
-                        zeile_A_Matrix.extend([d_r_dX_zp, d_r_dY_zp, d_r_dZ_zp])
+                            zeile_A_Matrix.extend([d_r_dX_zp, d_r_dY_zp, d_r_dZ_zp])
 
-                    else:
+                        else:
 
-                        zeile_A_Matrix.extend([0, 0, 0])
+                            zeile_A_Matrix.extend([0, 0, 0])
 
-                for orientierung in liste_orientierungsunbekannte:
+                    for orientierung in liste_orientierungsunbekannte:
-                    zeile_A_Matrix.append(d_r_dO_sp if orientierung == beobachtungsgruppeID else 0)
+                        zeile_A_Matrix.append(d_r_dO_sp if orientierung == beobachtungsgruppeID else 0)
 
-                liste_A_richtung_zeilen.append(zeile_A_Matrix)
+                    liste_A_richtung_zeilen.append(zeile_A_Matrix)
 
-                liste_zeilenbeschriftungen_richtung.append(
+                    liste_zeilenbeschriftungen_richtung.append(
 
-                    f"{beobachtungenID}_R_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}"
+                        f"{beobachtungenID}_R_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}"
 
-                )
+                    )
 
 
 
 
-            elif beobachtungsart == "tachymeter_zenitwinkel":
+                elif beobachtungsart == "tachymeter_zenitwinkel":
 
-                # Zenitwinkel nach Otepka (16), dB und dL bewusst weggelassen
+                    # Zenitwinkel nach Otepka (16), dB und dL bewusst weggelassen
 
-                dX = X_zp - X_sp
+                    dX = X_zp - X_sp
 
-                dY = Y_zp - Y_sp
+                    dY = Y_zp - Y_sp
 
-                dZ = Z_zp - Z_sp
+                    dZ = Z_zp - Z_sp
 
-                s_geom = sp.sqrt(dX ** 2 + dY ** 2 + dZ ** 2)
+                    s_geom = sp.sqrt(dX ** 2 + dY ** 2 + dZ ** 2)
 
-                z_loc = (sp.cos(B_sp) * sp.cos(L_sp)) * dX + (sp.cos(B_sp) * sp.sin(L_sp)) * dY + (sp.sin(B_sp)) * dZ
+                    z_loc = (sp.cos(B_sp) * sp.cos(L_sp)) * dX + (sp.cos(B_sp) * sp.sin(L_sp)) * dY + (sp.sin(B_sp)) * dZ
 
-                cos_zw = z_loc / s_geom
+                    cos_zw = z_loc / s_geom
 
-                sin_zw = sp.sqrt(1 - cos_zw ** 2)
+                    sin_zw = sp.sqrt(1 - cos_zw ** 2)
 
-                denom = (s_geom ** 2) * sin_zw
+                    denom = (s_geom ** 2) * sin_zw
 
-                d_zw_dX_zp = (dX * cos_zw - s_geom * sp.cos(B_sp) * sp.cos(L_sp)) / denom
+                    d_zw_dX_zp = (dX * cos_zw - s_geom * sp.cos(B_sp) * sp.cos(L_sp)) / denom
 
-                d_zw_dY_zp = (dY * cos_zw - s_geom * sp.cos(B_sp) * sp.sin(L_sp)) / denom
+                    d_zw_dY_zp = (dY * cos_zw - s_geom * sp.cos(B_sp) * sp.sin(L_sp)) / denom
 
-                d_zw_dZ_zp = (dZ * cos_zw - s_geom * sp.sin(B_sp)) / denom
+                    d_zw_dZ_zp = (dZ * cos_zw - s_geom * sp.sin(B_sp)) / denom
 
-                d_zw_dX_sp, d_zw_dY_sp, d_zw_dZ_sp = -d_zw_dX_zp, -d_zw_dY_zp, -d_zw_dZ_zp
+                    d_zw_dX_sp, d_zw_dY_sp, d_zw_dZ_sp = -d_zw_dX_zp, -d_zw_dY_zp, -d_zw_dZ_zp
 
-                zeile_A_Matrix = []
+                    zeile_A_Matrix = []
 
-                for punkt in liste_punktnummern:
+                    for punkt in liste_punktnummern:
 
-                    if punkt == standpunkt:
+                        if punkt == standpunkt:
 
-                        zeile_A_Matrix.extend([d_zw_dX_sp, d_zw_dY_sp, d_zw_dZ_sp])
+                            zeile_A_Matrix.extend([d_zw_dX_sp, d_zw_dY_sp, d_zw_dZ_sp])
 
-                    elif punkt == zielpunkt:
+                        elif punkt == zielpunkt:
 
-                        zeile_A_Matrix.extend([d_zw_dX_zp, d_zw_dY_zp, d_zw_dZ_zp])
+                            zeile_A_Matrix.extend([d_zw_dX_zp, d_zw_dY_zp, d_zw_dZ_zp])
 
-                    else:
+                        else:
 
-                        zeile_A_Matrix.extend([0, 0, 0])
+                            zeile_A_Matrix.extend([0, 0, 0])
 
-                # Zenitwinkel hat keine Orientierungsunbekannte
+                    # Zenitwinkel hat keine Orientierungsunbekannte
 
-                for orientierung in liste_orientierungsunbekannte:
+                    for orientierung in liste_orientierungsunbekannte:
-                    zeile_A_Matrix.append(0)
+                        zeile_A_Matrix.append(0)
 
-                liste_A_zenitwinkel_zeilen.append(zeile_A_Matrix)
+                    liste_A_zenitwinkel_zeilen.append(zeile_A_Matrix)
 
-                liste_zeilenbeschriftungen_zenitwinkel.append(
+                    liste_zeilenbeschriftungen_zenitwinkel.append(
 
-                    f"{beobachtungenID}_ZW_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}"
+                        f"{beobachtungenID}_ZW_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}"
 
-                )
+                    )
+
+        if liste_beobachtungen_rohdaten_gnssbasislinien != []:
+            for beobachtungsart, beobachtungenID, standpunkt, zielpunkt in liste_beobachtungen_rohdaten_gnssbasislinien:
+                X_sp, Y_sp, Z_sp = self.dict_punkt_symbole[standpunkt]
+                X_zp, Y_zp, Z_zp = self.dict_punkt_symbole[zielpunkt]
+
+                if beobachtungsart == "gnss_basislinien":
+                    beobachtungsgleichung_bx = X_zp - X_sp
+                    beobachtungsgleichung_by = Y_zp - Y_sp
+                    beobachtungsgleichung_bz = Z_zp - Z_sp
+                    liste_beobachtungsgleichungen_gnssbasislinien.append(beobachtungsgleichung_bx)
+                    liste_beobachtungsgleichungen_gnssbasislinien.append(beobachtungsgleichung_by)
+                    liste_beobachtungsgleichungen_gnssbasislinien.append(beobachtungsgleichung_bz)
+                    liste_zeilenbeschriftungen_gnssbasislinien.append(
+                        f"{beobachtungenID}_gnssbx_{standpunkt}_{zielpunkt}")
+                    liste_zeilenbeschriftungen_gnssbasislinien.append(
+                        f"{beobachtungenID}_gnssby_{standpunkt}_{zielpunkt}")
+                    liste_zeilenbeschriftungen_gnssbasislinien.append(
+                        f"{beobachtungenID}_gnssbz_{standpunkt}_{zielpunkt}")
 
         if liste_beobachtungsgleichungen_distanz:
             f_matrix_dist = sp.Matrix(liste_beobachtungsgleichungen_distanz)
@@ -238,6 +285,13 @@ class FunktionalesModell:
         else:
             A_zenitwinkel = None
 
+        if liste_beobachtungsgleichungen_gnssbasislinien:
+            f_matrix_gnss = sp.Matrix(liste_beobachtungsgleichungen_gnssbasislinien)
+            unbekanntenvektor = sp.Matrix(liste_unbekannte)
+            A_gnssbasislinien = f_matrix_gnss.jacobian(unbekanntenvektor)
+        else:
+            A_gnssbasislinien = None
+
         A_gesamt = None
         liste_zeilenbeschriftungen_gesamt = []
 
@@ -259,163 +313,46 @@ class FunktionalesModell:
                 A_gesamt = A_gesamt.col_join(A_zenitwinkel)
             liste_zeilenbeschriftungen_gesamt.extend(liste_zeilenbeschriftungen_zenitwinkel)
 
+        if A_gnssbasislinien is not None:
+            if A_gesamt is None:
+                A_gesamt = A_gnssbasislinien
+            else:
+                A_gesamt = A_gesamt.col_join(A_gnssbasislinien)
+            liste_zeilenbeschriftungen_gesamt.extend(liste_zeilenbeschriftungen_gnssbasislinien)
+
         if A_gesamt is None:
             return None
 
-        self.liste_unbekanntenvektor_symbolisch = liste_unbekannte
+        if datumsfestlegung == "weiche Lagerung":
+            vertauschung = list(range(len(liste_unbekannte)))
 
-        Export.matrix_to_csv(r"Zwischenergebnisse\Jacobi_Matrix_Symbolisch.csv", liste_unbekannte,
+            if liste_unbekannte_datumsfestlegung is not None and liste_unbekannte_datumsfestlegung != []:
-                             liste_zeilenbeschriftungen_gesamt, A_gesamt, "Beobachtung")
+                liste_unbekannte_alt = list(liste_unbekannte)
-        return A_gesamt, liste_unbekannte, liste_zeilenbeschriftungen_gesamt
+                liste_unbekannte_datumsfestlegung = [str(u).strip() for u in liste_unbekannte_datumsfestlegung]
+                idx_rechts = []
+                for name in liste_unbekannte_datumsfestlegung:
+                    for i, sym in enumerate(liste_unbekannte_alt):
+                        if str(sym) == name and i not in idx_rechts:
+                            idx_rechts.append(i)
+                            break
 
-    def jacobi_matrix_symbolisch_alt(self):
+                idx_links = [i for i in range(len(liste_unbekannte_alt)) if i not in idx_rechts]
-        #liste_beobachtungsarten = ["tachymeter_distanz", "tachymeter_richtung", "tachymeter_zenitwinkel"]
-        liste_beobachtungsarten = ["tachymeter_distanz", "tachymeter_richtung"]
-        db_zugriff = Datenbankzugriff(self.pfad_datenbank)
 
-        liste_beobachtungen_rohdaten = []
+                vertauschung = idx_links + idx_rechts
-        liste_punktnummern =[]
 
-        liste_orientierungsunbekannte = []
+                A_gesamt = A_gesamt[:, vertauschung]
+                liste_unbekannte = [liste_unbekannte_alt[i] for i in vertauschung]
 
-        for beobachtungsart in liste_beobachtungsarten:
+            # Zusatzgeleichungen der weichen Lagerung
-            liste_id_standpunkt_zielpunkt = db_zugriff.get_beobachtungen_id_beobachtungsgruppe_standpunkt_zielpunkt(beobachtungsart)
+            anzhl_einheitsmatrix = len(liste_unbekannte_datumsfestlegung)
+            if anzhl_einheitsmatrix > 0:
+                nullenmatrix = sp.zeros(anzhl_einheitsmatrix, A_gesamt.shape[1] - anzhl_einheitsmatrix)
+                einheitsmatrix = sp.eye(anzhl_einheitsmatrix)
+                A_weiche_Lagerung = nullenmatrix.row_join(einheitsmatrix)
+                A_gesamt = A_gesamt.col_join(A_weiche_Lagerung)
+                for unbekannte_datumsfestlegung in liste_unbekannte_datumsfestlegung:
+                    liste_zeilenbeschriftungen_gesamt.append(f"lA_{unbekannte_datumsfestlegung}")
 
-            for beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt in liste_id_standpunkt_zielpunkt:
-                liste_beobachtungen_rohdaten.append(
-                    (beobachtungsart, beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt)
-                )
-
-                if standpunkt not in liste_punktnummern:
-                    liste_punktnummern.append(standpunkt)
-                if zielpunkt not in liste_punktnummern:
-                    liste_punktnummern.append(zielpunkt)
-
-                if beobachtungsart == "tachymeter_richtung":
-                    if beobachtungsgruppeID not in liste_orientierungsunbekannte:
-                        liste_orientierungsunbekannte.append(beobachtungsgruppeID)
-        if liste_beobachtungen_rohdaten == []:
-            return None
-
-        #dict_punkt_symbole = {}
-        liste_unbekannte = []
-
-        for punkt in liste_punktnummern:
-            X, Y, Z = sp.symbols(f"X{punkt} Y{punkt} Z{punkt}")
-            self.dict_punkt_symbole[punkt] = (X, Y, Z)
-            liste_unbekannte.append(X)
-            liste_unbekannte.append(Y)
-            liste_unbekannte.append(Z)
-
-        dict_orientierung_symbole = {}
-        for orientierungsunbekannte in liste_orientierungsunbekannte:
-            O = sp.symbols(f"O{orientierungsunbekannte}")
-            dict_orientierung_symbole[orientierungsunbekannte] = O
-            liste_unbekannte.append(O)
-
-        liste_beobachtungsgleichungen_distanz =[]
-        liste_zeilenbeschriftungen_distanz = []
-
-        liste_A_richtung_zeilen = []
-        liste_zeilenbeschriftungen_richtung = []
-
-        for beobachtungsart, beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt in liste_beobachtungen_rohdaten:
-            X_sp, Y_sp, Z_sp = self.dict_punkt_symbole[standpunkt]
-            X_zp, Y_zp, Z_zp = self.dict_punkt_symbole[zielpunkt]
-            B_sp, L_sp = sp.symbols(f"B{standpunkt} L{standpunkt}")
-            alpha = sp.symbols(f"{beobachtungenID}_R_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
-            zw = sp.symbols(f"{beobachtungenID}_ZW_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
-            s = sp.symbols(f"{beobachtungenID}_SD_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
-
-            if beobachtungsart == "tachymeter_distanz":
-                beobachtungsgleichung = sp.sqrt(
-                    (X_zp - X_sp) ** 2
-                    + (Y_zp - Y_sp) ** 2
-                    + (Z_zp - Z_sp) ** 2
-                )
-                liste_beobachtungsgleichungen_distanz.append(beobachtungsgleichung)
-                liste_zeilenbeschriftungen_distanz.append(f"{beobachtungenID}_SD_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
-
-            if beobachtungsart == "tachymeter_richtung":
-                #for beobachtungenID, beobachtungsgruppeID, standpunkt, zielpunkt in liste_id_standpunkt_zielpunkt:
-                d_r_dX_zp = ((sp.sin(B_sp)*sp.cos(L_sp)*sp.sin(alpha) - sp.sin(L_sp)*sp.cos(alpha)) / (s * sp.sin(zw)))
-                d_r_dX_sp = - d_r_dX_zp
-                d_r_dY_zp = ((sp.sin(B_sp)*sp.sin(L_sp)*sp.sin(alpha) + sp.cos(L_sp)*sp.cos(alpha)) / (s * sp.sin(zw)))
-                d_r_dY_sp = - d_r_dY_zp
-                d_r_dZ_zp = ((-sp.cos(B_sp) * sp.sin(alpha) / (s * sp.sin(zw))))
-                d_r_dZ_sp = - d_r_dZ_zp
-                d_r_dO_sp = -1
-
-                zeile_A_Matrix = []
-                for punkt in liste_punktnummern:
-                    if punkt == standpunkt:
-                        zeile_A_Matrix.extend([d_r_dX_sp, d_r_dY_sp, d_r_dZ_sp])
-                    elif punkt == zielpunkt:
-                        zeile_A_Matrix.extend([d_r_dX_zp, d_r_dY_zp, d_r_dZ_zp])
-                    else:
-                        zeile_A_Matrix.extend([0, 0, 0])
-
-                for orientierung in liste_orientierungsunbekannte:
-                    if orientierung == beobachtungsgruppeID:
-                        zeile_A_Matrix.append(d_r_dO_sp)
-                    else:
-                        zeile_A_Matrix.append(0)
-
-                liste_A_richtung_zeilen.append(zeile_A_Matrix)
-                liste_zeilenbeschriftungen_richtung.append(
-                f"{beobachtungenID}_R_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}"
-            )
-
-            if beobachtungsart == "tachymeter_zenitwinkel":
-                d_r_dX_zp = ((X_zp - X_sp) * sp.cos(zw) - s * sp.cos(B_sp) * sp.cos(L_sp)) / (s ** 2 * sp.sin(zw))
-                d_r_dX_sp = - d_r_dX_zp
-                d_r_dY_zp = ((Y_zp - Y_sp) * sp.cos(zw) - s * sp.cos(B_sp) * sp.sin(L_sp)) / (s ** 2 * sp.sin(zw))
-                d_r_dY_sp = - d_r_dY_zp
-                d_r_dZ_zp = ((Z_zp - Z_sp) * sp.cos(zw) - s * sp.sin(B_sp)) / (s ** 2 * sp.sin(zw))
-                d_r_dZ_sp = - d_r_dZ_zp
-
-                zeile_A_Matrix = []
-                for punkt in liste_punktnummern:
-                    if punkt == standpunkt:
-                        zeile_A_Matrix.extend([d_r_dX_sp, d_r_dY_sp, d_r_dZ_sp])
-                    elif punkt == zielpunkt:
-                        zeile_A_Matrix.extend([d_r_dX_zp, d_r_dY_zp, d_r_dZ_zp])
-                    else:
-                        zeile_A_Matrix.extend([0, 0, 0])
-
-                for orientierung in liste_orientierungsunbekannte:
-                    zeile_A_Matrix.append(0)
-
-                liste_A_richtung_zeilen.append(zeile_A_Matrix)
-                liste_zeilenbeschriftungen_richtung.append(
-                    f"{beobachtungenID}_ZW_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}"
-                )
-
-        if liste_beobachtungsgleichungen_distanz:
-            f_matrix_dist = sp.Matrix(liste_beobachtungsgleichungen_distanz)
-            unbekanntenvektor = sp.Matrix(liste_unbekannte)
-            A_dist = f_matrix_dist.jacobian(unbekanntenvektor)
-        else:
-            A_dist = None
-
-        if liste_A_richtung_zeilen:
-            A_richtung = sp.Matrix(liste_A_richtung_zeilen)
-        else:
-            A_richtung = None
-
-        if A_dist is not None and A_richtung is not None:
-            A_gesamt = A_dist.col_join(A_richtung)
-            liste_zeilenbeschriftungen_gesamt = (
-                    liste_zeilenbeschriftungen_distanz + liste_zeilenbeschriftungen_richtung
-            )
-        elif A_dist is not None:
-            A_gesamt = A_dist
-            liste_zeilenbeschriftungen_gesamt = liste_zeilenbeschriftungen_distanz
-        elif A_richtung is not None:
-            A_gesamt = A_richtung
-            liste_zeilenbeschriftungen_gesamt = liste_zeilenbeschriftungen_richtung
-        else:
-            return None
 
         self.liste_unbekanntenvektor_symbolisch = liste_unbekannte
 
@@ -423,6 +360,7 @@ class FunktionalesModell:
                              liste_zeilenbeschriftungen_gesamt, A_gesamt, "Beobachtung")
         return A_gesamt, liste_unbekannte, liste_zeilenbeschriftungen_gesamt
 
+
     def jacobi_matrix_zahlen_iteration_0(self, A_symbolisch, koordinatenart, liste_unbekannte = None, liste_zeilenbeschriftungen_gesamt = None):
         self.liste_beobachtungsvektor_symbolisch = [str(x) for x in liste_zeilenbeschriftungen_gesamt]
 
@@ -449,150 +387,133 @@ class FunktionalesModell:
             print("Koordinaten noch nicht implementiert!")
 
     def beobachtungsvektor_numerisch(self, liste_beobachtungsvektor_symbolisch):
+
         liste_beobachtungsvektor_numerisch = []
         for beobachtung_symbolisch in liste_beobachtungsvektor_symbolisch:
+            beobachtung_symbolisch = str(beobachtung_symbolisch).strip()
+            if beobachtung_symbolisch.startswith("lA_"):
+                beobachtung_symbolisch = str(beobachtung_symbolisch.split("_", 1)[1]).strip()
             liste_beobachtungsvektor_numerisch.append(self.substitutionen_dict[sp.Symbol(beobachtung_symbolisch)])
 
         beobachtungsvektor_numerisch = sp.Matrix(liste_beobachtungsvektor_numerisch)
         Export.matrix_to_csv(r"Zwischenergebnisse\Beobachtungsvektor_Numerisch.csv", [""], liste_beobachtungsvektor_symbolisch, beobachtungsvektor_numerisch, "Beobachtungsvektor")
         return beobachtungsvektor_numerisch
 
-    def beobachtungsvektor_naeherung_symbolisch_alt(self, liste_beobachtungsvektor_symbolisch):
-        liste_beobachtungsgleichungen = []
-        self.dict_punkt_symbole = {}
-        liste_punktnummern = []
-
-        for beobachtung_symbolisch in liste_beobachtungsvektor_symbolisch:
-            aufgeteilt = beobachtung_symbolisch.split("_")
-            standpunkt = str(aufgeteilt[3])
-            zielpunkt = str(aufgeteilt[4])
-
-            if standpunkt not in liste_punktnummern:
-                liste_punktnummern.append(standpunkt)
-            if zielpunkt not in liste_punktnummern:
-                liste_punktnummern.append(zielpunkt)
-
-        for punkt in liste_punktnummern:
-            X, Y, Z = sp.symbols(f"X{punkt} Y{punkt} Z{punkt}")
-            self.dict_punkt_symbole[str(punkt)] = (X, Y, Z)
-
-        for beobachtung_symbolisch in liste_beobachtungsvektor_symbolisch:
-            aufgeteilt = beobachtung_symbolisch.split("_")
-            #beobachtungen_ID = aufgeteilt[0]
-            beobachtungsart = aufgeteilt[1]  # "SD", "R", "ZW"
-            #beobachtungsgruppeID = aufgeteilt[2]
-            standpunkt = str(aufgeteilt[3])
-            zielpunkt = str(aufgeteilt[4])
-
-            if beobachtungsart == "SD":
-                X_sp, Y_sp, Z_sp = self.dict_punkt_symbole[standpunkt]
-                X_zp, Y_zp, Z_zp = self.dict_punkt_symbole[zielpunkt]
-
-                beobachtungsgleichung = sp.sqrt(
-                    (X_zp - X_sp) ** 2
-                    + (Y_zp - Y_sp) ** 2
-                    + (Z_zp - Z_sp) ** 2
-                )
-                liste_beobachtungsgleichungen.append(beobachtungsgleichung)
-            elif beobachtungsart == "R":
-                X_sp, Y_sp, Z_sp = self.dict_punkt_symbole[standpunkt]
-                X_zp, Y_zp, Z_zp = self.dict_punkt_symbole[zielpunkt]
-
-                dX = X_zp - X_sp
-                dY = Y_zp - Y_sp
-                dZ = Z_zp - Z_sp
-
-                B_sp = sp.Symbol(f"B{standpunkt}")
-                L_sp = sp.Symbol(f"L{standpunkt}")
-
-                O_sp = sp.Symbol(f"O{beobachtungsgruppeID}")
-
-                x = (-sp.sin(B_sp) * sp.cos(L_sp)) * dX + (-sp.sin(B_sp) * sp.sin(L_sp)) * dY + (sp.cos(B_sp)) * dZ
-                y = (-sp.sin(L_sp)) * dX + (sp.cos(L_sp)) * dY
-
-                a12 = sp.atan2(y, x)
-
-                beobachtungsgleichung = a12 - O_sp
-                liste_beobachtungsgleichungen.append(beobachtungsgleichung)
-
-        beobachtungsvektor_naeherung_symbolisch = sp.Matrix(liste_beobachtungsgleichungen)
-        Export.matrix_to_csv(r"Zwischenergebnisse\Beobachtungsvektor_Näherung_Symbolisch.csv", [""],
-                             liste_beobachtungsvektor_symbolisch, beobachtungsvektor_naeherung_symbolisch, "Beobachtungsvektor")
-
-        return beobachtungsvektor_naeherung_symbolisch
-
     def beobachtungsvektor_naeherung_symbolisch(self, liste_beobachtungsvektor_symbolisch):
         liste_beobachtungsgleichungen = []
         self.dict_punkt_symbole = {}
         liste_punktnummern = []
 
         for beobachtung_symbolisch in liste_beobachtungsvektor_symbolisch:
-            aufgeteilt = beobachtung_symbolisch.split("_")
+            aufgeteilt = str(beobachtung_symbolisch).strip().split("_")
-            standpunkt = str(aufgeteilt[3])
+            if aufgeteilt[0] == "lA":
-            zielpunkt = str(aufgeteilt[4])
+                continue
 
-            if standpunkt not in liste_punktnummern:
+            if aufgeteilt [1] == "SD" or aufgeteilt [1] == "R" or aufgeteilt [1] == "ZW":
-                liste_punktnummern.append(standpunkt)
+                standpunkt = str(aufgeteilt[3])
-            if zielpunkt not in liste_punktnummern:
+                zielpunkt = str(aufgeteilt[4])
-                liste_punktnummern.append(zielpunkt)
+
+                if standpunkt not in liste_punktnummern:
+                    liste_punktnummern.append(standpunkt)
+                if zielpunkt not in liste_punktnummern:
+                    liste_punktnummern.append(zielpunkt)
+
+            if aufgeteilt[1] == "gnssbx" or aufgeteilt[1] == "gnssby" or aufgeteilt[1] == "gnssbz":
+                standpunkt = str(aufgeteilt[2])
+                zielpunkt = str(aufgeteilt[3])
+
+                if standpunkt not in liste_punktnummern:
+                    liste_punktnummern.append(standpunkt)
+                if zielpunkt not in liste_punktnummern:
+                    liste_punktnummern.append(zielpunkt)
 
         for punkt in liste_punktnummern:
             X, Y, Z = sp.symbols(f"X{punkt} Y{punkt} Z{punkt}")
             self.dict_punkt_symbole[str(punkt)] = (X, Y, Z)
 
         for beobachtung_symbolisch in liste_beobachtungsvektor_symbolisch:
+            beobachtung_symbolisch = str(beobachtung_symbolisch).strip()
             aufgeteilt = beobachtung_symbolisch.split("_")
-            #beobachtungen_ID = aufgeteilt[0]
+            if aufgeteilt[0] == "lA":
-            beobachtungsart = aufgeteilt[1]  # "SD", "R", "ZW"
+                anschlusspunkt = str(aufgeteilt[1])
-            beobachtungsgruppeID = aufgeteilt[2]
+                liste_beobachtungsgleichungen.append(sp.Symbol(anschlusspunkt))
-            standpunkt = str(aufgeteilt[3])
+                continue
-            zielpunkt = str(aufgeteilt[4])
 
-            X_sp, Y_sp, Z_sp = self.dict_punkt_symbole[standpunkt]
+            if aufgeteilt[1] == "SD" or aufgeteilt[1] == "R" or aufgeteilt[1] == "ZW":
-            X_zp, Y_zp, Z_zp = self.dict_punkt_symbole[zielpunkt]
 
-            dX = X_zp - X_sp
+                #beobachtungen_ID = aufgeteilt[0]
-            dY = Y_zp - Y_sp
+                beobachtungsart = aufgeteilt[1]  # "SD", "R", "ZW"
-            dZ = Z_zp - Z_sp
+                beobachtungsgruppeID = aufgeteilt[2]
-            s = sp.sqrt(dX ** 2 + dY ** 2 + dZ ** 2)  # Schrägstrecke
+                standpunkt = str(aufgeteilt[3]).strip()
+                zielpunkt = str(aufgeteilt[4]).strip()
 
-            B_sp = sp.Symbol(f"B{standpunkt}")
+                X_sp, Y_sp, Z_sp = self.dict_punkt_symbole[standpunkt]
-            L_sp = sp.Symbol(f"L{standpunkt}")
+                X_zp, Y_zp, Z_zp = self.dict_punkt_symbole[zielpunkt]
-
-            if beobachtungsart == "SD":
-
-                s_geom = sp.sqrt(dX ** 2 + dY ** 2 + dZ ** 2)
-                liste_beobachtungsgleichungen.append(s_geom)
-
-            elif beobachtungsart == "R":
-
-                O_sp = sp.Symbol(f"O{beobachtungsgruppeID}")
-
-                # Lokales System: x_loc = Nord, y_loc = Ost
-                x_loc = (-sp.sin(B_sp) * sp.cos(L_sp)) * dX + (-sp.sin(B_sp) * sp.sin(L_sp)) * dY + (sp.cos(B_sp)) * dZ
-                y_loc = (-sp.sin(L_sp)) * dX + (sp.cos(L_sp)) * dY
-
-                a12 = sp.atan2(y_loc, x_loc)
-
-                # Richtung nach Otepka: r = a12 - O
-                liste_beobachtungsgleichungen.append(a12 - O_sp)
-
-
-            elif beobachtungsart == "ZW":
 
                 dX = X_zp - X_sp
-
                 dY = Y_zp - Y_sp
+                dZ = Z_zp - Z_sp
+                s = sp.sqrt(dX ** 2 + dY ** 2 + dZ ** 2)  # Schrägstrecke
 
+                B_sp = sp.Symbol(f"B{standpunkt}")
+                L_sp = sp.Symbol(f"L{standpunkt}")
+
+                if beobachtungsart == "SD":
+
+                    s_geom = sp.sqrt(dX ** 2 + dY ** 2 + dZ ** 2)
+                    liste_beobachtungsgleichungen.append(s_geom)
+
+                elif beobachtungsart == "R":
+
+                    #O_sp = sp.Symbol(f"O_{beobachtungsgruppeID}")
+                    r_sp_zp = sp.Symbol(f"richtung_berechnet_{standpunkt}_{zielpunkt}")
+
+                    # Lokales System: x_loc = Nord, y_loc = Ost
+                    #x_loc = (-sp.sin(B_sp) * sp.cos(L_sp)) * dX + (-sp.sin(B_sp) * sp.sin(L_sp)) * dY + (sp.cos(B_sp)) * dZ
+                    #y_loc = (-sp.sin(L_sp)) * dX + (sp.cos(L_sp)) * dY
+
+                    #a12 = sp.atan2(y_loc, x_loc)
+
+                    # Richtung nach Otepka: r = a12 - O
+                    liste_beobachtungsgleichungen.append(r_sp_zp)
+
+
+                elif beobachtungsart == "ZW":
+
+                    #dX = X_zp - X_sp
+
+                    #dY = Y_zp - Y_sp
+
+                    #dZ = Z_zp - Z_sp
+
+                    #s_geom = sp.sqrt(dX ** 2 + dY ** 2 + dZ ** 2)
+
+                    #z_loc = (sp.cos(B_sp) * sp.cos(L_sp)) * dX + (sp.cos(B_sp) * sp.sin(L_sp)) * dY + (sp.sin(B_sp)) * dZ
+
+                    #zw = sp.acos(z_loc / s_geom)
+
+                    zw_sp_zp = sp.Symbol(f"zw_berechnet_{standpunkt}_{zielpunkt}")
+
+                    liste_beobachtungsgleichungen.append(zw_sp_zp)
+
+            if aufgeteilt[1] == "gnssbx" or aufgeteilt[1] == "gnssby" or aufgeteilt[1] == "gnssbz":
+                beobachtungsart = aufgeteilt[1]
+                standpunkt = str(aufgeteilt[2]).strip()
+                zielpunkt = str(aufgeteilt[3]).strip()
+
+                X_sp, Y_sp, Z_sp = self.dict_punkt_symbole[standpunkt]
+                X_zp, Y_zp, Z_zp = self.dict_punkt_symbole[zielpunkt]
+
+                dX = X_zp - X_sp
+                dY = Y_zp - Y_sp
                 dZ = Z_zp - Z_sp
 
-                s_geom = sp.sqrt(dX ** 2 + dY ** 2 + dZ ** 2)
+                if beobachtungsart == "gnssbx":
-
+                    liste_beobachtungsgleichungen.append(dX)
-                z_loc = (sp.cos(B_sp) * sp.cos(L_sp)) * dX + (sp.cos(B_sp) * sp.sin(L_sp)) * dY + (sp.sin(B_sp)) * dZ
+                if beobachtungsart == "gnssby":
-
+                    liste_beobachtungsgleichungen.append(dY)
-                zw = sp.acos(z_loc / s_geom)
+                if beobachtungsart == "gnssbz":
-
+                    liste_beobachtungsgleichungen.append(dZ)
-                liste_beobachtungsgleichungen.append(zw)
 
         beobachtungsvektor_naeherung_symbolisch = sp.Matrix(liste_beobachtungsgleichungen)
         Export.matrix_to_csv(r"Zwischenergebnisse\Beobachtungsvektor_Näherung_Symbolisch.csv", [""],
@@ -665,6 +586,8 @@ class FunktionalesModell:
         dict_unbekanntenvektor_numerisch = {}
         index = 0
 
+        unbekanntenvektor_numerisch = np.asarray(unbekanntenvektor_numerisch, dtype=float).reshape(-1, 1)
+
         for symbol in liste_unbekanntenvektor_symbolisch:
             name = str(symbol)
             if not name.startswith("X"):
@@ -673,9 +596,9 @@ class FunktionalesModell:
             punktnummer = str(name[1:])
 
             dict_unbekanntenvektor_numerisch[punktnummer] = sp.Matrix([
-                float(unbekanntenvektor_numerisch[index]),
+                float(unbekanntenvektor_numerisch[index, 0]),
-                float(unbekanntenvektor_numerisch[index + 1]),
+                float(unbekanntenvektor_numerisch[index + 1, 0]),
-                float(unbekanntenvektor_numerisch[index + 2])
+                float(unbekanntenvektor_numerisch[index + 2, 0])
             ])
             index += 3
         return dict_unbekanntenvektor_numerisch
@@ -696,6 +619,7 @@ class FunktionalesModell:
 
     def dict_substitutionen_uebergeordnetes_system(self, unbekanntenvektor_aus_iteration = None):
         db_zugriff = Datenbankzugriff(self.pfad_datenbank)
+        berechnungen = Berechnungen(self.a, self.b)
         if unbekanntenvektor_aus_iteration is None:
             dict_koordinaten = db_zugriff.get_koordinaten("naeherung_us")
         else:
@@ -704,8 +628,15 @@ class FunktionalesModell:
                 unbekanntenvektor_aus_iteration
             )
 
+        for punktnummer, matrix in dict_koordinaten.items():
+            dict_koordinaten[punktnummer] = [float(matrix[0]), float(matrix[1]), float(matrix[2])]
+
+
+        liste_beobachtungen_tachymeter = db_zugriff.get_beobachtungen_from_beobachtungenid()
+        liste_beobachtungen_gnssbasislinien = db_zugriff.get_beobachtungen_gnssbasislinien()
+        liste_azimut_richtungen, dict_orientierungen = self.berechnungen.berechnung_richtung_azimut_zenitwinkel(self.pfad_datenbank, dict_koordinaten)
         dict_koordinaten_B_L = self.berechnungen.geometrische_breite_laenge(dict_koordinaten)
-        liste_beobachtungen = db_zugriff.get_beobachtungen_from_beobachtungenid()
+
         substitutionen = {}
 
         for punktnummer, vektor in dict_koordinaten_B_L.items():
@@ -718,18 +649,47 @@ class FunktionalesModell:
             substitutionen[B_sym] = float(vektor[1])
             substitutionen[L_Sym] = float(vektor[2])
 
-        for standpunkt, zielpunkt, beobachtungenID, beobachtungsgruppeID, tachymeter_richtung, tachymeter_zenitwinkel, tachymeter_distanz in liste_beobachtungen:
+        #for beobachtungsgruppeID, orientierung in dict_orientierungen.items():
-            alpha = sp.symbols(f"{beobachtungenID}_R_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
+        #    O_sym = sp.symbols(f"O_{beobachtungsgruppeID}")
-            zw = sp.symbols(f"{beobachtungenID}_ZW_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
+        #    substitutionen[O_sym] = float(orientierung)
-            s = sp.symbols(f"{beobachtungenID}_SD_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
 
-            if tachymeter_richtung is None and tachymeter_zenitwinkel is None and tachymeter_distanz is None:
+        for standpunkt, zielpunkt, azimut, richtung, zenitwinkel in liste_azimut_richtungen:
+            richtung_sym = sp.symbols(f"richtung_berechnet_{standpunkt}_{zielpunkt}")
+            substitutionen[richtung_sym] = float(richtung)
+
+            zenitwinkel_sym = sp.symbols(f"zw_berechnet_{standpunkt}_{zielpunkt}")
+            substitutionen[zenitwinkel_sym] = float(zenitwinkel)
+
+
+
+        #for standpunkt, zielpunkt, beobachtungenID, beobachtungsgruppeID, tachymeter_richtung, tachymeter_zenitwinkel, tachymeter_distanz in liste_beobachtungen_tachymeter:
+            #alpha = sp.symbols(f"{beobachtungenID}_R_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
+            #zw = sp.symbols(f"{beobachtungenID}_ZW_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
+            #s = sp.symbols(f"{beobachtungenID}_SD_{beobachtungsgruppeID}_{standpunkt}_{zielpunkt}")
+
+            #if tachymeter_richtung is None and tachymeter_zenitwinkel is None and tachymeter_distanz is None:
+            #    continue
+
+            #substitutionen[alpha] = float(tachymeter_richtung)
+            #substitutionen[zw] = float(tachymeter_zenitwinkel)
+            #substitutionen[s] = float(tachymeter_distanz)
+            #substitutionen[sp.Symbol(f"O{beobachtungsgruppeID}")] = 0.0
+
+        for beobachtungenID, punktnummer_sp, punktnummer_zp, gnss_bx, gnss_by, gnss_bz, gnss_s0, gnss_cxx, gnss_cxy, gnss_cxz, gnss_cyy, gnss_cyz, gnss_czz in liste_beobachtungen_gnssbasislinien:
+            beobachtungenID = str(beobachtungenID).strip()
+            punktnummer_sp = str(punktnummer_sp).strip()
+            punktnummer_zp = str(punktnummer_zp).strip()
+
+            bx = sp.symbols(f"{beobachtungenID}_gnssbx_{punktnummer_sp}_{punktnummer_zp}")
+            by = sp.symbols(f"{beobachtungenID}_gnssby_{punktnummer_sp}_{punktnummer_zp}")
+            bz = sp.symbols(f"{beobachtungenID}_gnssbz_{punktnummer_sp}_{punktnummer_zp}")
+
+            if gnss_bx is None and gnss_by is None and gnss_bz is None:
                 continue
 
-            substitutionen[alpha] = float(tachymeter_richtung)
+            substitutionen[bx] = float(gnss_bx)
-            substitutionen[zw] = float(tachymeter_zenitwinkel)
+            substitutionen[by] = float(gnss_by)
-            substitutionen[s] = float(tachymeter_distanz)
+            substitutionen[bz] = float(gnss_bz)
-            substitutionen[sp.Symbol(f"O{beobachtungsgruppeID}")] = 0.0
 
         if unbekanntenvektor_aus_iteration is not None:
             dict_O = self.unbekanntenvektor_numerisch_to_dict_orientierungen(
@@ -739,7 +699,7 @@ class FunktionalesModell:
             for orientierungs_id, wert in dict_O.items():
                 substitutionen[sp.Symbol(f"O{orientierungs_id}")] = float(wert)
         else:
-            for standpunkt, zielpunkt, beobachtungenID, beobachtungsgruppeID, *_ in liste_beobachtungen:
+            for standpunkt, zielpunkt, beobachtungenID, beobachtungsgruppeID, *_ in liste_beobachtungen_tachymeter:
                 O_sym = sp.Symbol(f"O{beobachtungsgruppeID}")
                 if O_sym not in substitutionen:
                     substitutionen[O_sym] = 0
@@ -749,11 +709,11 @@ class FunktionalesModell:
     def unbekanntenvektor_numerisch_to_dict_orientierungen(self, liste_unbekanntenvektor_symbolisch,
                                                            unbekanntenvektor_numerisch):
         dict_O = {}
-
+        unbekanntenvektor_numerisch = np.asarray(unbekanntenvektor_numerisch, dtype=float).reshape(-1, 1)
         for i, symbol in enumerate(liste_unbekanntenvektor_symbolisch):
             name = str(symbol)
             if name.startswith("O"):
                 orientierungs_id = name[1:]
-                dict_O[orientierungs_id] = float(unbekanntenvektor_numerisch[i])
+                dict_O[orientierungs_id] = float(unbekanntenvektor_numerisch[i, 0])
 
         return dict_O

Import.py

@@ -90,6 +90,9 @@ class Import:
             except:
                 nummer_beobachtungsgruppeID = 0
 
+            if nummer_beobachtungsgruppeID is None:
+                nummer_beobachtungsgruppeID = 0
+
             with (open(pfad_datei, "r", encoding="utf-8") as f):
                 liste_fehlerhafte_zeile = []
                 liste_beobachtungen_vorbereitung = []
@@ -189,7 +192,7 @@ class Import:
                         zenitwinkel_vollsatz_rad = Berechnungen.Einheitenumrechnung.gon_to_rad_Decimal(zenitwinkel_vollsatz_gon)
                         distanz_vollsatz = (self.string_to_decimal(liste_aktueller_zielpunkt[7]) + self.string_to_decimal(
                             liste[7])) / 2
-                        if richtung2 < 0:
+                        if richtung2 < 0 and richtung1 != Decimal(0):
                             richtung2 += Decimal(400)
                         elif richtung2 > 400:
                             richtung2 -= Decimal(400)
@@ -585,3 +588,56 @@ class Import:
         con.close()
         return "Import der Koordinaten aus stationärem GNSS abgeschlossen."
 
+    def import_basislinien_gnss(self, pfad_datei):
+        Import_fortsetzen = True
+
+        # Prüfen, ob Bereits Daten aus der Datei in der Datenbank vorhanden sind
+        con = sqlite3.connect(self.pfad_datenbank)
+        cursor = con.cursor()
+        liste_dateinamen_in_db = [r[0] for r in cursor.execute(
+            "SELECT DISTINCT dateiname FROM Beobachtungen"
+        ).fetchall()]
+        con.close()
+        cursor.close
+
+        if pfad_datei in liste_dateinamen_in_db:
+            Import_fortsetzen = False
+
+        if Import_fortsetzen:
+            liste_basilinien = []
+            tupel_basislinie = ()
+            with (open(pfad_datei, "r", encoding="utf-8") as txt):
+                for i, zeile in enumerate(txt):
+                    zeile = str(zeile).rstrip("\n").rstrip("\r")
+                    aufgeteilt = zeile.split()
+                    if aufgeteilt[0][:2] == "@+":
+                        #print(aufgeteilt[0][2:])
+                        tupel_basislinie += (aufgeteilt[0][2:],)
+                    if aufgeteilt[0][:2] == "@-":
+                        #print(aufgeteilt[0][2:], aufgeteilt[1], aufgeteilt[2], aufgeteilt[3])
+                        tupel_basislinie += (aufgeteilt[0][2:], aufgeteilt[1], aufgeteilt[2], aufgeteilt[3],)
+                    if aufgeteilt[0][:2] == "@=":
+                        #print(aufgeteilt[1], aufgeteilt[2], aufgeteilt[3], aufgeteilt[4], aufgeteilt[5], aufgeteilt[6], aufgeteilt[7])
+                        tupel_basislinie += (aufgeteilt[1], aufgeteilt[2], aufgeteilt[3], aufgeteilt[4], aufgeteilt[5], aufgeteilt[6], aufgeteilt[7], )
+                        liste_basilinien.append(tupel_basislinie)
+                        tupel_basislinie = ()
+                #print(liste_basilinien)
+
+        else:
+            print(
+                f"Der Import wurde abgebrochen, weil die Beobachtungen aus der Datei {pfad_datei} bereits in der Datenbank vorhanden sind.")
+
+        if Import_fortsetzen:
+            con = sqlite3.connect(self.pfad_datenbank)
+            cursor = con.cursor()
+            for basislinie in liste_basilinien:
+                cursor.execute(
+                    "INSERT INTO Beobachtungen (punktnummer_sp, punktnummer_zp, gnss_bx, gnss_by, gnss_bz, gnss_s0, gnss_cxx, gnss_cxy, gnss_cxz, gnss_cyy, gnss_cyz, gnss_czz, dateiname) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                    (basislinie[0], basislinie[1], float(basislinie[2]), float(basislinie[3]), float(basislinie[4]), float(basislinie[5]), float(basislinie[6]), float(basislinie[7]), float(basislinie[8]), float(basislinie[9]), float(basislinie[10]), float(basislinie[11]), pfad_datei))
+            con.commit()
+            cursor.close()
+            con.close()
+            print(f"Der Import der Datei {pfad_datei} wurde erfolgreich abgeschlossen.")
+
+
+

Netzqualität_Genauigkeit.py

@@ -1,168 +1,113 @@
-from dataclasses import dataclass
-from typing import Sequence, List, Dict
-import sympy as sp
 import numpy as np
-import math
+import plotly.graph_objects as go
-from decimal import Decimal
+from scipy.stats import f as f_dist
-import matplotlib.pyplot as plt
 
 
-@dataclass
 class Genauigkeitsmaße:
-    def __init__(self):
+
-        pass
 
     @staticmethod
-    def s0apost(v, P, r):
+    def berechne_s0apost(v: np.ndarray, P: np.ndarray, r: int) -> float:
-        vv = (v.T * P * v)[0, 0]
+        vTPv_matrix = v.T @ P @ v
-        vv = float(vv)  # Sympy -> float
+        vTPv = float(vTPv_matrix.item())
-
+        s0apost = np.sqrt(vTPv / r)
-        if r <= 0:
+        return float(s0apost)
-            raise ValueError(f"Redundanz r muss > 0 sein, ist {r}.")
-        if not math.isfinite(vv):
-            raise ValueError(f"vv ist nicht endlich (NaN/Inf). vv={vv}")
-        if vv < 0:
-            raise ValueError(f"vv ist negativ. vv={vv}")
-
-        return math.sqrt(vv / float(r))
 
 
-
+    @staticmethod
-    def helmertscher_punktfehler_3D(self, sigma_x: float, sigma_y: float, sigma_z: float) -> float:
+    def berechne_helmert_punktfehler_3D(Qxx_matrix: np.ndarray, s0apost: float, punkt_namen: list) -> dict:
-        sx = sp.sympify(sigma_x)
+        helmert_punktfehler_ergebnisse_3D = {}
-        sy = sp.sympify(sigma_y)
+        diag_Q = np.diag(Qxx_matrix)
-        sz = sp.sympify(sigma_z)
+        if len(diag_Q) < len(punkt_namen) * 3:
-
+            raise ValueError("Die Matrix Qxx ist zu klein für die Anzahl der Punkte (3D erwartet).")
-        helmert_pf_3D = sp.sqrt(sx**2 + sy**2 + sz**2)
+        for i, name in enumerate(punkt_namen):
-        return float(helmert_pf_3D)
+            idx_x, idx_y, idx_z = 3 * i, 3 * i + 1, 3 * i + 2
+            q_xx, q_yy, q_zz = diag_Q[idx_x], diag_Q[idx_y], diag_Q[idx_z]
+            helmert_punktfehler_3D = s0apost * np.sqrt(q_xx + q_yy + q_zz)
+            helmert_punktfehler_ergebnisse_3D[name] = round(float(helmert_punktfehler_3D), 4)
+        return helmert_punktfehler_ergebnisse_3D
 
 
-    def helmertscher_punktfehler_3D_alle(
+    @staticmethod
-        self,
+    def berechne_standardellipsen(Qxx: np.ndarray, s0: float, punkt_namen: list):
-        sigma_x_list: Sequence[float],
+        standardellipsen = []
-        sigma_y_list: Sequence[float],
+        for i, name in enumerate(punkt_namen):
-        sigma_z_list: Sequence[float],
+            ix, iy = 3 * i, 3 * i + 1
-    ) -> List[float]:
+            qxx, qyy, qxy = Qxx[ix, ix], Qxx[iy, iy], Qxx[ix, iy]
-        if not (
+            k = np.sqrt((qxx - qyy) ** 2 + 4 * qxy ** 2)
-            len(sigma_x_list) == len(sigma_y_list) == len(sigma_z_list)
+            qa, qb = 0.5 * (qxx + qyy + k), 0.5 * (qxx + qyy - k)
-        ):
+            a, b = s0 * np.sqrt(qa), s0 * np.sqrt(qb)
-            raise ValueError("Listen sigma_x, sigma_y, sigma_z müssen gleich lang sein.")
+            theta = 0.5 * np.arctan2(2 * qxy, qxx - qyy)
-
+            standardellipsen.append({
-        return [
+                "name": name, "a": a, "b": b, "theta": theta, "prob": 0.39  # Standard ca. 39%
-            self.helmertscher_punktfehler_3D(sx, sy, sz)
+            })
-            for sx, sy, sz in zip(sigma_x_list, sigma_y_list, sigma_z_list)
+        return standardellipsen
-        ]
 
 
-    def fehlerellipse_standard_2D(
+    @staticmethod
-        self,
+    def berechne_konfidenzellipsen(Qxx: np.ndarray, s0: float, r: int, punkt_namen: list,
-        Q_xx: float,
+                                   wahrscheinlichkeit: float = 0.95):
-        Q_yy: float,
+        # Quantil der F-Verteilung (df1=2 für die Ebene, df2=r für Redundanz)
-        Q_xy: float,
+        f_quantil = f_dist.ppf(wahrscheinlichkeit, 2, r)
-        sigma_0: float,
+        k_faktor = np.sqrt(2 * f_quantil)
-    ) -> Dict[str, float]:
 
-        Q_xx_s = sp.sympify(Q_xx)
+        standard_ellipsen = Genauigkeitsmaße.berechne_standardellipsen(Qxx, s0, punkt_namen)
-        Q_yy_s = sp.sympify(Q_yy)
+        konfidenz_ellipsen = []
-        Q_xy_s = sp.sympify(Q_xy)
+        for ell in standard_ellipsen:
-        sigma0_s = sp.sympify(sigma_0)
+            konfidenz_ellipsen.append({
-
+                "name": ell['name'],
-        k = sp.sqrt((Q_xx_s - Q_yy_s)**2 + 4 * Q_xy_s**2)
+                "a": ell['a'] * k_faktor,
-
+                "b": ell['b'] * k_faktor,
-        Q_dmax = sp.Rational(1, 2) * (Q_xx_s + Q_yy_s + k)
+                "theta": ell['theta'],
-        Q_dmin = sp.Rational(1, 2) * (Q_xx_s + Q_yy_s - k)
+                "prob": wahrscheinlichkeit,
-
+                "k_faktor": k_faktor
-        s_max = sigma0_s * sp.sqrt(Q_dmax)
+            })
-        s_min = sigma0_s * sp.sqrt(Q_dmin)
+        return konfidenz_ellipsen
-
-        theta_rad = sp.Rational(1, 2) * sp.atan2(2 * Q_xy_s, Q_xx_s - Q_yy_s)
-        theta_gon = theta_rad * 200 / sp.pi
-
-        return {
-            "Q_dmax": float(Q_dmax),
-            "Q_dmin": float(Q_dmin),
-            "s_max": float(s_max),
-            "s_min": float(s_min),
-            "theta_rad": float(theta_rad),
-            "theta_gon": float(theta_gon),
-        }
 
 
+    @staticmethod
+    def plot_ellipsen(punkt_coords: dict, ellipsen_parameter: list, scale: float = 1000):
+        fig = go.Figure()
 
-    def fehlerellipse_konfidenz_2D(
+        # Titel dynamisch anpassen
-        self,
+        prob = ellipsen_parameter[0].get('prob', 0)
-        s_max: float,
+        titel = "Standard-Fehlerellipsen" if prob < 0.4 else f"{prob * 100:.0f}% Konfidenzellipsen"
-        s_min: float,
-        scale_value: float,
-    ) -> Dict[str, float]:
 
-        s_max_s = sp.sympify(s_max)
+        for p in ellipsen_parameter:
-        s_min_s = sp.sympify(s_min)
+            name = p['name']
-        scale_s = sp.sympify(scale_value)
+            x0, y0 = punkt_coords[name][0], punkt_coords[name][1]
+            a, b, theta = p['a'], p['b'], p['theta']
 
-        faktor = sp.sqrt(scale_s)
+            t = np.linspace(0, 2 * np.pi, 100)
+            xs, ys = a * scale * np.cos(t), b * scale * np.sin(t)
 
-        A_K = faktor * s_max_s
+            x_plot = x0 + xs * np.cos(theta) - ys * np.sin(theta)
-        B_K = faktor * s_min_s
+            y_plot = y0 + xs * np.sin(theta) + ys * np.cos(theta)
 
-        return {
+            # Punkt
-            "A_K": float(A_K),
+            fig.add_trace(go.Scatter(
-            "B_K": float(B_K),
+                x=[x0], y=[y0], mode='markers+text',
-        }
+                name=f"Punkt {name}", text=[name], textposition="top right",
+                marker=dict(size=8, color='black')
+            ))
 
+            # Ellipse
+            fig.add_trace(go.Scatter(
+                x=x_plot, y=y_plot, mode='lines',
+                name=f"Ellipse {name}",
+                line=dict(color='blue' if prob > 0.4 else 'red', width=2,
+                          dash='dash' if prob > 0.4 else 'solid'),
+                fill='toself',
+                fillcolor='rgba(0, 0, 255, 0.1)' if prob > 0.4 else 'rgba(255, 0, 0, 0.1)',
+                hoverinfo='text',
+                text=(f"Punkt: {name}<br>a: {a * 1000:.2f} mm<br>"
+                      f"b: {b * 1000:.2f} mm<br>Theta: {np.degrees(theta):.2f}°")
+            ))
 
-
+        fig.update_layout(
-    def plot_ellipsen_alle(
+            title=titel,
-        self,
+            xaxis_title="Rechtswert (E) [m]", yaxis_title="Hochwert (N) [m]",
-        x_list: Sequence[float],
+            yaxis=dict(scaleanchor="x", scaleratio=1),
-        y_list: Sequence[float],
+            template="plotly_white", showlegend=True
-        Q_xx_list: Sequence[float],
+        )
-        Q_yy_list: Sequence[float],
+        return fig
-        Q_xy_list: Sequence[float],
-        sigma_0: float,
-        scale_value: float | None = None,  # None = Standardellipse, sonst Konfidenzellipse
-    ) -> plt.Axes:
-
-        n = len(x_list)
-        if not (
-            n == len(y_list) == len(Q_xx_list) == len(Q_yy_list) == len(Q_xy_list)
-        ):
-            raise ValueError("Alle Listen müssen gleich lang sein (ein Eintrag pro Punkt).")
-
-        fig, ax = plt.subplots()
-
-        for i in range(n):
-            std = self.fehlerellipse_standard_2D(
-                Q_xx_list[i], Q_yy_list[i], Q_xy_list[i], sigma_0
-            )
-            s_max = std["s_max"]
-            s_min = std["s_min"]
-            theta = std["theta_rad"]
-
-            # ggf. Konfidenzellipse statt Standardellipse
-            if scale_value is not None:
-                konf = self.fehlerellipse_konfidenz_2D(s_max, s_min, scale_value)
-                A = konf["A_K"]
-                B = konf["B_K"]
-            else:
-                A = s_max
-                B = s_min
-
-            t = np.linspace(0, 2 * np.pi, 200)
-            ct = np.cos(theta)
-            st = np.sin(theta)
-
-            x_local = A * np.cos(t)
-            y_local = B * np.sin(t)
-
-            x_ell = x_list[i] + ct * x_local - st * y_local
-            y_ell = y_list[i] + st * x_local + ct * y_local
-
-            ax.plot(x_ell, y_ell, linewidth=0.8)
-            ax.plot(x_list[i], y_list[i], marker=".", color="k", markersize=3)
-
-        ax.set_aspect("equal", "box")
-        ax.grid(True)
-        ax.set_xlabel("x")
-        ax.set_ylabel("y")
-        return ax

Netzqualität_Zuverlässigkeit.py

@@ -5,6 +5,31 @@ import sympy as sp
 
 @dataclass
 class Zuverlaessigkeit:
+    import numpy as np
+    import pandas as pd
+
+    def berechne_redundanzanteile(res_dict: dict, beobachtungen_labels: list) -> pd.DataFrame:
+
+        # 1. Redundanzmatrix R abrufen
+        # R = Qvv * P
+        R = res_dict.get("R")
+
+        if R is None:
+            raise ValueError("Die Redundanzmatrix R wurde im res_dict nicht gefunden.")
+
+        # 2. Diagonalelemente extrahieren (das sind die r_i Werte)
+        r_anteile = np.diag(R)
+
+        # 3. Ergebnisse in einem Pandas DataFrame zusammenfassen
+        df_redundanz = pd.DataFrame({
+            "Beobachtung": beobachtungen_labels,
+            "r_i": np.round(r_anteile, 4),  # Dezimal (0 bis 1)
+            "r_i_prozent": np.round(r_anteile * 100, 2)  # In Prozent (0 bis 100%)
+        })
+
+        return df_redundanz
+
+
 
     def redundanzanalyse(self, r_vec: Sequence[float]) -> Dict[str, object]:
         r_s = [sp.sympify(r) for r in r_vec]

Parameterschaetzung.py

@@ -2,6 +2,7 @@ from Stochastisches_Modell import StochastischesModell
 from Netzqualität_Genauigkeit import Genauigkeitsmaße
 from Datumsfestlegung import Datumsfestlegung
 import sympy as sp
+import numpy as np
 import Export
 
 
@@ -28,6 +29,8 @@ def ausgleichung_global(
 
     # 2) Gewichtsmatrix P
     P = StochastischesModell.berechne_P(Q_ext)
+    if isinstance(P, np.ndarray):
+        P = sp.Matrix(P)
 
     # 3) Normalgleichungsmatrix N und Absolutgliedvektor n
     N = A_ext.T * P * A_ext
@@ -147,4 +150,100 @@ def ausgleichung_lokal(
     }
 
     Export.Export.ausgleichung_to_datei(r"Zwischenergebnisse\Ausgleichung_Iteration0_lokal.csv", dict_ausgleichung_lokal)
-    return dict_ausgleichung_lokal, dx
+    return dict_ausgleichung_lokal, dx
+
+
+
+
+def ausgleichung_lokal_numpy(
+    A,
+    dl,
+    Q_ll,
+    x0,
+    liste_punktnummern,
+    auswahl,
+    mit_massstab: bool = True,
+):
+
+    A = np.asarray(A, dtype=float)
+    dl = np.asarray(dl, dtype=float).reshape(-1, 1)
+    Q_ll = np.asarray(Q_ll, dtype=float)
+    x0 = np.asarray(x0, dtype=float).reshape(-1, 1)
+
+    # 1) Gewichtsmatrix
+    P = np.linalg.inv(Q_ll)
+
+    # 2) Normalgleichungen
+    N = A.T @ P @ A
+    n = A.T @ P @ dl
+
+    # 3) Datum: G, E, Gi
+    # -> Datumsfestlegung ist sympy-basiert, daher nur dafür kurz Sympy verwenden
+    x0_sp = sp.Matrix(x0)
+    G = Datumsfestlegung.raenderungsmatrix_G(x0_sp, liste_punktnummern, mit_massstab=mit_massstab)
+    aktive = Datumsfestlegung.datumskomponenten(auswahl, liste_punktnummern)
+    E = Datumsfestlegung.auswahlmatrix_E(u=A.shape[1], aktive_unbekannte_indices=aktive)
+    Gi_sp = E * G
+
+    Gi = np.asarray(Gi_sp, dtype=float)  # zurück nach numpy
+
+    # 4) gerändertes System lösen:
+    # [N  Gi] [dx] = [n]
+    # [GiT 0] [k ]   [0]
+    u = N.shape[0]
+    d = Gi.shape[1]
+
+    K = np.block([
+        [N,      Gi],
+        [Gi.T, np.zeros((d, d))]
+    ])
+    rhs = np.vstack([n, np.zeros((d, 1))])
+
+    sol = np.linalg.solve(K, rhs)
+    dx = sol[:u, :]
+
+    # 5) Residuen
+    v = dl - A @ dx
+
+    # 6) Qxx (innere Lösung)
+    N_inv = np.linalg.inv(N)
+    N_inv_G = N_inv @ Gi
+    S = Gi.T @ N_inv_G
+    print("rank(Gi) =", np.linalg.matrix_rank(Gi))
+    print("Gi shape =", Gi.shape)
+    print("rank(S)  =", np.linalg.matrix_rank(S))
+    print("S shape  =", S.shape)
+    S_inv = np.linalg.inv(S)
+    Q_xx = N_inv - N_inv_G @ S_inv @ N_inv_G.T
+
+    # 7) Q_lhat_lhat, Q_vv
+    Q_lhat_lhat = A @ Q_xx @ A.T
+    Q_vv = np.linalg.inv(P) - Q_lhat_lhat
+
+    # 8) Redundanz
+    R = Q_vv @ P
+    r_vec = np.diag(R).reshape(-1, 1)
+    n_beob = A.shape[0]
+    u = A.shape[1]
+    d = Gi.shape[1]
+    r_gesamt = n_beob - u + d
+
+    # 9) sigma0
+    vv = float(v.T @ P @ v)
+    sigma0_apost = float(np.sqrt(vv / r_gesamt))
+
+    return {
+        "dx": dx,
+        "v": v,
+        "P": P,
+        "N": N,
+        "Q_xx": Q_xx,
+        "Q_lhat_lhat": Q_lhat_lhat,
+        "Q_vv": Q_vv,
+        "R": R,
+        "r": r_vec,
+        "r_gesamt": r_gesamt,
+        "sigma0_apost": sigma0_apost,
+        "G": np.asarray(G, dtype=float),
+        "Gi": Gi,
+    }, dx

Stochastisches_Modell.py

@@ -8,7 +8,7 @@ from Datenbank import Datenbankzugriff
 @dataclass
 class StochastischesModell:
     n_beob: int
-    sigma_beob: Iterable[float] =None            #σ a priori der einzelnen Beobachtung
+    sigma_beob: Iterable[float] =None           #σ a priori der einzelnen Beobachtung
     gruppe_beob: Iterable[int]   =None           #Gruppenzugehörigkeit jeder Beobachtung (Distanz, Richtung, GNSS, Nivellement,...,)
     sigma0_gruppe: Dict[int, float] = field(default_factory=dict)  #σ0² für jede Gruppe
 
@@ -74,6 +74,7 @@ class StochastischesModell:
     def Qll_symbolisch(self, pfad_datenbank, liste_beobachtungen_symbolisch):
         liste_standardabweichungen_symbole = []
         liste_beobachtungen_symbolisch = [str(b) for b in liste_beobachtungen_symbolisch]
+        liste_beobachtungen_symbolisch = [b for b in liste_beobachtungen_symbolisch if not b.startswith("lA_")]
         Qll = sp.zeros(len(liste_beobachtungen_symbolisch), len(liste_beobachtungen_symbolisch))
 
         db_zugriff = Datenbankzugriff(pfad_datenbank)
@@ -81,52 +82,113 @@ class StochastischesModell:
 
         for i, beobachtung_symbolisch_i in enumerate(liste_beobachtungen_symbolisch):
             aufgeteilt_i = beobachtung_symbolisch_i.split("_")
-            beobachtungenID_i = int(aufgeteilt_i[0])
-            instrumenteID_i = dict_beobachtungenID_instrumenteID[beobachtungenID_i]
-            beobachtungsart_i = str(aufgeteilt_i[1])
 
-            if beobachtungsart_i == "SD":
+            if aufgeteilt_i[1] == "SD" or aufgeteilt_i[1] == "R" or aufgeteilt_i[1] == "ZW":
-                stabw_apriori_konstant = sp.Symbol(f"stabw_apriori_konstant_{beobachtungsart_i}_{instrumenteID_i}")
+                beobachtungenID_i = int(aufgeteilt_i[0])
-                stabw_apriori_streckenprop = sp.Symbol(f"stabw_apriori_streckenprop_{beobachtungsart_i}_{instrumenteID_i}")
+                instrumenteID_i = dict_beobachtungenID_instrumenteID[beobachtungenID_i]
-                tachymeter_distanz = sp.Symbol(f"SD_{beobachtungenID_i}")
+                beobachtungsart_i = str(aufgeteilt_i[1])
 
-                sigma = sp.sqrt(stabw_apriori_konstant ** 2 + (stabw_apriori_streckenprop * tachymeter_distanz / 1000000) ** 2)
+                if beobachtungsart_i == "SD":
-                liste_standardabweichungen_symbole.append(sigma)
+                    stabw_apriori_konstant = sp.Symbol(f"stabw_apriori_konstant_{beobachtungsart_i}_{instrumenteID_i}")
+                    stabw_apriori_streckenprop = sp.Symbol(f"stabw_apriori_streckenprop_{beobachtungsart_i}_{instrumenteID_i}")
+                    tachymeter_distanz = sp.Symbol(f"SD_{beobachtungenID_i}")
 
-                Qll[i, i] = sigma ** 2
+                    sigma = sp.sqrt(stabw_apriori_konstant ** 2 + (stabw_apriori_streckenprop * tachymeter_distanz / 1000000) ** 2)
+                    liste_standardabweichungen_symbole.append(sigma)
 
-            elif beobachtungsart_i == "R" or beobachtungsart_i == "ZW":
+                    Qll[i, i] = sigma ** 2
-                stabw_apriori_konstant = sp.Symbol(f"stabw_apriori_konstant_{beobachtungsart_i}_{instrumenteID_i}")
 
-                stabw_apriori_konstant_distanz = sp.Symbol(f"stabw_apriori_konstant_SD_{instrumenteID_i}")
+                elif beobachtungsart_i == "R" or beobachtungsart_i == "ZW":
-                tachymeter_distanz = sp.Symbol(f"SD_{beobachtungenID_i}")
+                    stabw_apriori_konstant = sp.Symbol(f"stabw_apriori_konstant_{beobachtungsart_i}_{instrumenteID_i}")
 
-                sigma = sp.sqrt(
+                    stabw_apriori_konstant_distanz = sp.Symbol(f"stabw_apriori_konstant_SD_{instrumenteID_i}")
-                    stabw_apriori_konstant ** 2 + (stabw_apriori_konstant_distanz / tachymeter_distanz) ** 2)
+                    tachymeter_distanz = sp.Symbol(f"SD_{beobachtungenID_i}")
-                liste_standardabweichungen_symbole.append(sigma)
 
-                Qll[i, i] = sigma ** 2
+                    sigma = sp.sqrt(
+                        stabw_apriori_konstant ** 2 + (stabw_apriori_konstant_distanz / tachymeter_distanz) ** 2)
+                    liste_standardabweichungen_symbole.append(sigma)
 
-            for j in range(i + 1, len(liste_beobachtungen_symbolisch)):
+                    Qll[i, i] = sigma ** 2
-                beobachtung_symbolisch_j = liste_beobachtungen_symbolisch[j]
-                aufgeteilt_j = beobachtung_symbolisch_j.split("_")
-                beobachtungsart_j = str(aufgeteilt_j[1])
 
-                if beobachtungsart_i == "SD" and beobachtungsart_j == "SD":
+                for j in range(i + 1, len(liste_beobachtungen_symbolisch)):
-                    Qll[i, j] = 0
+                    beobachtung_symbolisch_j = liste_beobachtungen_symbolisch[j]
-                    Qll[j, i] = 0
+                    aufgeteilt_j = beobachtung_symbolisch_j.split("_")
+                    beobachtungsart_j = str(aufgeteilt_j[1])
+
+                    if beobachtungsart_i == "SD" and beobachtungsart_j == "SD":
+                        Qll[i, j] = 0
+                        Qll[j, i] = 0
+            if aufgeteilt_i [1] == "gnssbx" or aufgeteilt_i[1] == "gnssby" or aufgeteilt_i[1] == "gnssbz":
+                beobachtungenID_i = int(aufgeteilt_i[0])
+                beobachtungsart_i = str(aufgeteilt_i[1])
+
+                if beobachtungsart_i == "gnssbx":
+                    cxx = sp.symbols(f"cxx_{beobachtungenID_i}")
+                    s0 = sp.symbols(f"s0_{beobachtungenID_i}**2")
+                    liste_standardabweichungen_symbole.append(cxx)
+                    Qll[i, i] = cxx * s0
+
+                    cxy = sp.Symbol(f"cxy_{beobachtungenID_i}")
+                    s0 = sp.symbols(f"s0_{beobachtungenID_i}**2")
+                    for j in range(i + 1, len(liste_beobachtungen_symbolisch)):
+                        beobachtung_symbolisch_j = liste_beobachtungen_symbolisch[j]
+                        aufgeteilt_j = beobachtung_symbolisch_j.split("_")
+
+                        if int(aufgeteilt_j[0]) == beobachtungenID_i and aufgeteilt_j[1] == "gnssby":
+                            Qll[i, j] = cxy * s0
+                            Qll[j, i] = cxy * s0
+                            break
+
+                    cxz = sp.Symbol(f"cxz_{beobachtungenID_i}")
+                    s0 = sp.symbols(f"s0_{beobachtungenID_i}**2")
+                    for j in range(i + 1, len(liste_beobachtungen_symbolisch)):
+                        beobachtung_symbolisch_j = liste_beobachtungen_symbolisch[j]
+                        aufgeteilt_j = beobachtung_symbolisch_j.split("_")
+
+                        if int(aufgeteilt_j[0]) == beobachtungenID_i and aufgeteilt_j[1] == "gnssbz":
+                            Qll[i, j] = cxz * s0
+                            Qll[j, i] = cxz * s0
+                            break
+
+                if beobachtungsart_i == "gnssby":
+                    cyy = sp.symbols(f"cyy_{beobachtungenID_i}")
+                    s0 = sp.symbols(f"s0_{beobachtungenID_i}**2")
+                    liste_standardabweichungen_symbole.append(cyy)
+                    Qll[i, i] = cyy * s0
+
+                    cyz = sp.Symbol(f"cyz_{beobachtungenID_i}")
+                    s0 = sp.symbols(f"s0_{beobachtungenID_i}**2")
+                    for j in range(i + 1, len(liste_beobachtungen_symbolisch)):
+                        beobachtung_symbolisch_j = liste_beobachtungen_symbolisch[j]
+                        aufgeteilt_j = beobachtung_symbolisch_j.split("_")
+
+                        if int(aufgeteilt_j[0]) == beobachtungenID_i and aufgeteilt_j[1] == "gnssbz":
+                            Qll[i, j] = cyz * s0
+                            Qll[j, i] = cyz * s0
+                            break
+
+                if beobachtungsart_i == "gnssbz":
+                    czz = sp.symbols(f"czz_{beobachtungenID_i}")
+                    s0 = sp.symbols(f"s0_{beobachtungenID_i}**2")
+                    liste_standardabweichungen_symbole.append(czz)
+                    Qll[i, i] = czz * s0
 
         Export.matrix_to_csv(r"Zwischenergebnisse\Qll_Symbolisch.csv", liste_beobachtungen_symbolisch, liste_beobachtungen_symbolisch, Qll, "Qll")
         return Qll
 
     def Qll_numerisch(self, pfad_datenbank, Qll_Matrix_Symbolisch, liste_beobachtungen_symbolisch):
+        liste_beobachtungen_symbolisch = [str(b).strip() for b in liste_beobachtungen_symbolisch]
+        liste_beobachtungen_symbolisch = [b for b in liste_beobachtungen_symbolisch if not b.startswith("lA_")]
+
         db_zugriff = Datenbankzugriff(pfad_datenbank)
         dict_genauigkeiten = db_zugriff.get_genauigkeiten_dict()
         dict_beobachtungenID_instrumenteID = db_zugriff.get_instrumenteID_beobachtungenID_dict()
 
-        liste_beobachtungen = db_zugriff.get_beobachtungen_from_beobachtungenid()
+        liste_beobachtungen_tachymeter = db_zugriff.get_beobachtungen_from_beobachtungenid()
+        liste_beobachtungen_gnss = db_zugriff.get_beobachtungen_gnssbasislinien()
+
         dict_beobachtungenID_distanz = {}
-        for standpunkt, zielpunkt, beobachtungenID, beobachtungsgruppeID, tachymeter_richtung, tachymeter_zenitwinkel, tachymeter_distanz in liste_beobachtungen:
+        for standpunkt, zielpunkt, beobachtungenID, beobachtungsgruppeID, tachymeter_richtung, tachymeter_zenitwinkel, tachymeter_distanz in liste_beobachtungen_tachymeter:
             dict_beobachtungenID_distanz[int(beobachtungenID)] = tachymeter_distanz
 
         dict_genauigkeiten_neu = {}
@@ -176,6 +238,29 @@ class StochastischesModell:
             if distanz is not None:
                 substitutionen[sp.Symbol(f"SD_{beobachtungenID}")] = float(distanz)
 
+        #GNSS Basislinien
+        for gnss_beobachtungen in liste_beobachtungen_gnss:
+            beobachtungenID = gnss_beobachtungen[0]
+            gnss_s0 = gnss_beobachtungen[6]
+            gnss_cxx = gnss_beobachtungen[7]
+            gnss_cxy = gnss_beobachtungen[8]
+            gnss_cxz = gnss_beobachtungen[9]
+            gnss_cyy = gnss_beobachtungen[10]
+            gnss_cyz = gnss_beobachtungen[11]
+            gnss_czz = gnss_beobachtungen[12]
+
+            substitutionen[sp.Symbol(f"cxx_{beobachtungenID}")] = float(gnss_cxx)
+            substitutionen[sp.Symbol(f"cxy_{beobachtungenID}")] = float(gnss_cxy)
+            substitutionen[sp.Symbol(f"cxz_{beobachtungenID}")] = float(gnss_cxz)
+            substitutionen[sp.Symbol(f"cyy_{beobachtungenID}")] = float(gnss_cyy)
+            substitutionen[sp.Symbol(f"cyz_{beobachtungenID}")] = float(gnss_cyz)
+            substitutionen[sp.Symbol(f"czz_{beobachtungenID}")] = float(gnss_czz)
+            substitutionen[sp.Symbol(f"s0_{beobachtungenID}")] = float(gnss_s0)
+
+
+
+
+
         #Qll_numerisch = Qll_Matrix_Symbolisch.xreplace(substitutionen)
         if (self.func_Qll_numerisch is None) or (set(self.liste_symbole_lambdify) != set(substitutionen.keys())):
             self.liste_symbole_lambdify = sorted(substitutionen.keys(), key=lambda s: str(s))
@@ -196,8 +281,68 @@ class StochastischesModell:
             Qll_numerisch,
             "Qll"
         )
+
         return Qll_numerisch
 
+    def QAA_symbolisch(self, liste_beobachtungen_symbolisch):
+        liste_standardabweichungen_symbole = []
+        liste_beobachtungen_symbolisch = [str(b) for b in liste_beobachtungen_symbolisch]
+        liste_beobachtungen_symbolisch = [b for b in liste_beobachtungen_symbolisch if b.startswith("lA_")]
+        Qll = sp.zeros(len(liste_beobachtungen_symbolisch), len(liste_beobachtungen_symbolisch))
+
+        for i, beobachtung_symbolisch_i in enumerate(liste_beobachtungen_symbolisch):
+            aufgeteilt_i = beobachtung_symbolisch_i.split("_")
+            datumskoordinate = str(aufgeteilt_i[1])
+            beobachtungsart_i = str(aufgeteilt_i[0])
+
+            if beobachtungsart_i == "lA":
+                sigma = sp.Symbol(f"StabwAA_{datumskoordinate}")
+                liste_standardabweichungen_symbole.append(sigma)
+
+                Qll[i, i] = sigma ** 2
+
+        Export.matrix_to_csv(r"Zwischenergebnisse\QAA_Symbolisch.csv", liste_beobachtungen_symbolisch, liste_beobachtungen_symbolisch, Qll, "Qll")
+        return Qll
+
+    def QAA_numerisch(self, pfad_datenbank, QAA_Matrix_Symbolisch, liste_beobachtungen_symbolisch):
+        liste_beobachtungen_symbolisch = [str(b).strip() for b in liste_beobachtungen_symbolisch]
+        liste_beobachtungen_symbolisch = [b for b in liste_beobachtungen_symbolisch if b.startswith("lA_")]
+
+        db_zugriff = Datenbankzugriff(pfad_datenbank)
+        dict_stabwAA_vorinfo = db_zugriff.get_stabw_AA_Netzpunkte()
+
+        substitutionen = {}
+
+        for koordinate, stabwAA in dict_stabwAA_vorinfo.items():
+            substitutionen[sp.Symbol(str(koordinate).strip())] = float(stabwAA)
+
+        if not hasattr(self, "func_QAA_numerisch"):
+            self.func_QAA_numerisch = None
+        if not hasattr(self, "liste_symbole_lambdify_QAA"):
+            self.liste_symbole_lambdify_QAA = []
+
+        if (self.func_QAA_numerisch is None) or (set(self.liste_symbole_lambdify_QAA) != set(substitutionen.keys())):
+            self.liste_symbole_lambdify_QAA = sorted(substitutionen.keys(), key=lambda s: str(s))
+            self.func_QAA_numerisch = sp.lambdify(
+                self.liste_symbole_lambdify_QAA,
+                QAA_Matrix_Symbolisch,
+                modules="numpy",
+                cse=True
+            )
+
+        liste_werte = [substitutionen[s] for s in self.liste_symbole_lambdify_QAA]
+        QAA_numerisch = np.asarray(self.func_QAA_numerisch(*liste_werte), dtype=float)
+
+        Export.matrix_to_csv(
+            r"Zwischenergebnisse\QAA_Numerisch.csv",
+            liste_beobachtungen_symbolisch,
+            liste_beobachtungen_symbolisch,
+            QAA_numerisch,
+            "QAA"
+        )
+
+        return QAA_numerisch
+
     @staticmethod
     def berechne_P(Q_ll):
         return np.linalg.inv(Q_ll)