Pythonfiles

Parameterschaetzung.py

@@ -1,29 +1,62 @@
-from Datumsfestlegung import *
 from Stochastisches_Modell import StochastischesModell
+from Netzqualität_Genauigkeit import Genauigkeitsmaße
+from Datumsfestlegung import Datumsfestlegung
 import sympy as sp
 import Export
-import Netzqualität_Genauigkeit
 
 
-def ausgleichung_global(A, dl, stoch_modell: StochastischesModell):
+def ausgleichung_global(
+    A: sp.Matrix,
+    dl: sp.Matrix,
+    Q_ll: sp.Matrix,
+    x0: sp.Matrix,
+    idx_X, idx_Y, idx_Z,
+    anschluss_indices,
+    anschluss_werte,
+    Sigma_AA,
+):
+    # 1) Datumsfestlegung (weiches Datum) System erweitern
+    A_ext, dl_ext, Q_ext = Datumsfestlegung.weiches_datum(
+        A=A,
+        dl=dl,
+        Q_ll=Q_ll,
+        x0=x0,
+        anschluss_indices=anschluss_indices,
+        anschluss_werte=anschluss_werte,
+        Sigma_AA=Sigma_AA,
+    )
 
-    #Q_ll, P = stoch_modell.berechne_Qll_P()        #Kofaktormatrix und P-Matrix
-    P = sp.eye(A.shape[0])
-    N = A.T * P * A                                 #Normalgleichungsmatrix N
-    Q_xx = N.inv()                                  #Kofaktormatrix der Unbekannten Qxx
-    n = A.T * P * dl                                #Absolutgliedvektor n
+    # 2) Gewichtsmatrix P
+    P = StochastischesModell.berechne_P(Q_ext)
 
-    dx = N.LUsolve(n)                               #Zuschlagsvektor dx
+    # 3) Normalgleichungsmatrix N und Absolutgliedvektor n
+    N = A_ext.T * P * A_ext
+    n = A_ext.T * P * dl_ext
 
-    v = dl - A * dx                                 #Residuenvektor v
+    # 4) Zuschlagsvektor dx
+    dx = N.LUsolve(n)
 
+    # 5) Residuenvektor v
+    v = dl - A * dx
+
+    # 6) Kofaktormatrix der Unbekannten Q_xx
+    Q_xx = StochastischesModell.berechne_Q_xx(N)
+
+    # 7) Kofaktormatrix der Beobachtungen Q_ll_dach
     Q_ll_dach = A * Q_xx * A.T
-    Q_vv = stoch_modell.berechne_Qvv(A, P, Q_xx)          #Kofaktormatrix der Verbesserungen Qvv
-    R = stoch_modell.berechne_R(Q_vv, P)                  #Redundanzmatrix R
-    r = stoch_modell.berechne_r(R)                        #Redundanzanteile als Vektor r
-    redundanzanteile = A.shape[0] - A.shape[1] #n-u+d
-    soaposteriori = Netzqualität_Genauigkeit.Genauigkeitsmaße.s0apost(v, P, redundanzanteile)
 
+    # 8) Kofaktormatrix der Verbesserungen Q_vv
+    Q_vv = StochastischesModell.berechne_Qvv(A, P, Q_xx)
+
+    # 9) Redundanzmatrix R und Redundanzanteile r
+    R = StochastischesModell.berechne_R(Q_vv, P)                  #Redundanzmatrix R
+    r = StochastischesModell.berechne_r(R)                        #Redundanzanteile als Vektor r
+    redundanzanteile = A.shape[0] - A.shape[1] #n-u+d
+
+    # 10) s0 a posteriori
+    soaposteriori = Genauigkeitsmaße.s0apost(v, P, redundanzanteile)
+
+    # 11) Ausgabe
     dict_ausgleichung = {
         "dx": dx,
         "v": v,
@@ -38,68 +71,65 @@ def ausgleichung_global(A, dl, stoch_modell: StochastischesModell):
     }
 
     Export.Export.ausgleichung_to_datei(r"Zwischenergebnisse\Ausgleichung_Iteration0.csv", dict_ausgleichung)
-
     return dict_ausgleichung, dx
 
 
 
+
 def ausgleichung_lokal(
     A: sp.Matrix,
     dl: sp.Matrix,
-    stoch_modell: StochastischesModell,
+    Q_ll: sp.Matrix,
     x0: sp.Matrix,
     idx_X, idx_Y, idx_Z,
     aktive_unbekannte_indices,
     mit_massstab: bool = True,
 ):
-    # 1) Gewichte
-    Q_ll, P = stoch_modell.berechne_Qll_P()
-    # Debug-Option:
-    # P = sp.eye(A.rows)
+    # 1) Gewichtsmatrix P
+    P = StochastischesModell.berechne_P(Q_ll)
 
-    # 2) Normalgleichungen
+    # 2) Normalgleichungsmatrix N und Absolutgliedvektor n
     N = A.T * P * A
     n = A.T * P * dl
 
-    # 3) Datum (G, E, Gi)
-    G = raenderungsmatrix_G(x0, idx_X, idx_Y, idx_Z, mit_massstab=mit_massstab)
-    E = auswahlmatrix_E(u=A.cols, aktive_unbekannte_indices=aktive_unbekannte_indices)
+    # 3) Datumsfestlegung (Teilspurminimierung)
+    G = Datumsfestlegung.raenderungsmatrix_G(x0, liste_punktnummern, mit_massstab=mit_massstab)
+    aktive = Datumsfestlegung.datumskomponenten(auswahl, liste_punktnummern)
+    E = Datumsfestlegung.auswahlmatrix_E(u=A.cols, aktive_unbekannte_indices=aktive)
     Gi = E * G
 
-    # 4) Geränderte Lösung (dx)
-    dx = berechne_dx_geraendert(N, n, Gi)
+    # 4) Zuschlagsvektor dx
+    dx = Datumsfestlegung.berechne_dx_geraendert(N, n, Gi)
 
-    # 5) Residuen
+    # 5) Residuenvektor v
     v = dl - A * dx
 
-    # 6) KORREKTE Q_xx für gerändertes Problem:
-    # Q_xx = N^{-1} - N^{-1}Gi (Gi^T N^{-1} Gi)^{-1} Gi^T N^{-1}
-    # numerisch besser via LUsolve statt inv:
-    N_inv = N.inv()  # wenn N groß ist, kann man das unten auch ohne inv machen (siehe Hinweis)
+    # 6) Kofaktormatrix der Unbekannten Q_xx
+    N_inv = N.inv()
     N_inv_G = N_inv * Gi
     S = Gi.T * N_inv_G
     S_inv = S.inv()
     Q_xx = N_inv - N_inv_G * S_inv * N_inv_G.T
 
-    # 7) Q_lhat_lhat und Q_vv
+    # 7) Kofaktormatrix der Beobachtungen Q_ll_dach
     Q_lhat_lhat = A * Q_xx * A.T
+
+    # 8) Kofaktormatrix der Verbesserungen Q_vv
     Q_vv = P.inv() - Q_lhat_lhat
 
-    # 8) Redundanzmatrix und -anteile
+    # 9) Redundanzmatrix R, Redundanzanteile r, Redundanz
     R = Q_vv * P
     r_vec = sp.Matrix(R.diagonal())
-
-    # 9) Freiheitsgrade (Redundanz gesamt)
     n_beob = A.rows
     u = A.cols
     d = Gi.shape[1]
     r_gesamt = n_beob - u + d
 
-    # 10) sigma0 a posteriori
-    omega = float((v.T * P * v)[0, 0])
-    sigma0_hat = (omega / float(r_gesamt)) ** 0.5
+    # 10) s0 a posteriori
+    sigma0_apost = Genauigkeitsmaße.s0apost(v, P, r_gesamt)
 
-    return {
+    # 11) Ausgabe
+    dict_ausgleichung_lokal = {
         "dx": dx,
         "v": v,
         "Q_ll": Q_ll,
@@ -111,7 +141,10 @@ def ausgleichung_lokal(
         "R": R,
         "r": r_vec,
         "r_gesamt": r_gesamt,
-        "sigma0_hat": sigma0_hat,
+        "sigma0_apost": sigma0_apost,
         "G": G,
         "Gi": Gi,
-    }
+    }
+
+    Export.Export.ausgleichung_to_datei(r"Zwischenergebnisse\Ausgleichung_Iteration0_lokal.csv", dict_ausgleichung_lokal)
+    return dict_ausgleichung_lokal, dx