#!/bin/sh
#
# RadarSudoku.tcl von Jochen Meyer-Hilberg
# Mit Anregungen von Wolfgang Wittekind und Christoph Neumann
# 07.10.2007, 13.10.2007, 20.10.2007, 27.10.2007, 01.11.2007, 04.11.2007,
# 10.11.2007, 17.11.2007, 05.01.2008, 12.01.2008, 19.01.2008, 08.03.2008,
# 19.04.2017, 20.04.2017, 21.04.2017, 22.04.2017, 24.04.2017, 26.02.2020
#
# Die nächste Zeile startet wish \
exec wish "$0" "$@"

wm title . "Radar-Sudoku"
wm minsize . 1100 600
wm geometry . +0+26
wm protocol . WM_DELETE_WINDOW exit

set autoren "Idee: Dr. Wolfgang Wittekind"
set autoren "$autoren, Ausführung: Dr. Jochen Meyer-Hilberg"
set autoren "$autoren (Version vom 26. Februar 2020)"

label .titel -font -*-helvetica-bold-r-normal--34-*- -text "Radar-Sudoku"
label .autoren -font -*-helvetica-bold-r-normal--17-*- -text "$autoren"
frame .feld
frame .knopf
pack .titel .autoren -side top -padx 2m -pady 2m
pack .feld -side top -expand yes -padx 2m -pady 2m
pack .knopf -side bottom -fill x

button .knopf.neu -text "Alle Werte löschen" -command LoescheAlleParameter \
  -state disabled
button .knopf.lesen -text "Werte einlesen" -command LiesParameter
button .knopf.schreiben -text "Werte abspeichern" -command SchreibeParameter
button .knopf.sprache -command WechselDieSprache
button .knopf.nicht -text "Hier nicht drücken!" -command NichtDruecken
button .knopf.ende -text "Fenster schließen" -command exit
pack .knopf.neu .knopf.lesen .knopf.schreiben .knopf.sprache .knopf.nicht \
  .knopf.ende -side left -expand yes -pady 2m -fill x

bind . q exit

set anzahl_gleichungen 18
set anzahl_parameter   28

set etitel(1)  "Wavelength \[mm\]"
set etitel(2)  "Carrier Frequency \[GHz\]"
set etitel(3)  "Signal Bandwidth \[MHz\]"
set etitel(4)  "Pulse-Repetition Frequency \[Hz\]"
set etitel(5)  "Coherent Time-on-Target \[s\]"
set etitel(6)  "Effective Synthetic Aperture Length \[m\]"
set etitel(7)  "Observation Angle \[deg\]"
set etitel(8)  "Aperture Dimension in Azimuth \[m\]"
set etitel(9)  "Antenna 3dB Azimuth Beamwidth \[deg\]"
set etitel(10) "Azimuth Sector Size \[deg\]"
set etitel(11) "Scan Time per Azimuth Sector \[s\]"
set etitel(12) "Pulse Compression Factor"
set etitel(13) "Pulse Length \[us\]"
set etitel(14) "Duty Factor \[%\]"
set etitel(15) "Target Range \[km\]"
set etitel(16) "Sensor Platform Velocity \[m/s\]"
set etitel(17) "Minimum Range \[m\]"
set etitel(18) "Unambiguous Range \[km\]"
set etitel(19) "Unambiguous Crossrange \[m\]"
set etitel(20) "Unambiguous Velocity \[m/s\]"
set etitel(21) "Size of Range Gate \[m\]"
set etitel(22) "Size of Crossrange Gate (Doppler Cell) \[m\]"
set etitel(23) "Size of Velocity Gate (Doppler Cell) \[m/s\]"
set etitel(24) "Maximum Number of Range Gates"
set etitel(25) "Number of Doppler Cells (Pulses)"
set etitel(26) "Maximum SNR Gain due to Doppler FFT \[dB\]"
set etitel(27) "Squint Angle relative to Velocity \[deg\]"
set etitel(28) "Number of Doppler Cells with Ground Clutter"

set dtitel(1)  "Wellenlänge \[mm\]"
set dtitel(2)  "Trägerfrequenz \[GHz\]"
set dtitel(3)  "Signalbandbreite \[MHz\]"
set dtitel(4)  "Impulsfolgefrequenz \[Hz\]"
set dtitel(5)  "Kohärente Zielbeobachtungszeit \[s\]"
set dtitel(6)  "Effektive Länge der synthetischen Apertur \[m\]"
set dtitel(7)  "Beobachtungswinkel \[Grad\]"
set dtitel(8)  "Aperturabmessung in Azimut \[m\]"
set dtitel(9)  "Antennenkeulenhalbwertsbreite in Azimut \[Grad\]"
set dtitel(10) "Azimutsektorgröße \[Grad\]"
set dtitel(11) "Absuchdauer pro Azimutsektor \[s\]"
set dtitel(12) "Impulskompressionsfaktor"
set dtitel(13) "Impulslänge \[us\]"
set dtitel(14) "Tastverhältnis \[%\]"
set dtitel(15) "Zielentfernung \[km\]"
set dtitel(16) "Geschwindigkeit der Sensorplattform \[m/s\]"
set dtitel(17) "Minimalentfernung \[m\]"
set dtitel(18) "Eindeutige Reichweite \[km\]"
set dtitel(19) "Eindeutiger Querrichtungsbereich \[m\]"
set dtitel(20) "Eindeutiger Geschwindigkeitsbereich \[m/s\]"
set dtitel(21) "Größe eines Entfernungstors \[m\]"
set dtitel(22) "Größe eines Querrichtungstors (Dopplerzelle) \[m\]"
set dtitel(23) "Größe eines Geschwindigkeitstors (Dopplerzelle) \[m/s\]"
set dtitel(24) "Maximale Anzahl Entfernungstore"
set dtitel(25) "Anzahl Dopplerzellen (Impulse)"
set dtitel(26) "Maximaler S/N-Gewinn durch Doppler-FFT \[dB\]"
set dtitel(27) "Keulensteuerwinkel relativ zur Geschwindigkeit \[Grad\]"
set dtitel(28) "Anzahl Dopplerzellen mit Bodenechos"

set mitte [ expr int (ceil (($anzahl_parameter + 1.0) / 2.0)) ]

for { set index 1 } { $index < $mitte } { incr index } {
  label .feld.titel$index
  button .feld.$index -width 20 -command "WaehleParameter $index"
  grid .feld.titel$index -row $index -column 1 -sticky nse
  grid .feld.$index      -row $index -column 2 -sticky nsew
  set status($index)    0
  set parameter($index) 0
}

set alt_index 0

if { $mitte != [ expr $anzahl_parameter / 2.0 + 1.0 ] } {
  button .feld.blind -width 20 -command { UebernehmeParameter $alt_index }
  grid .feld.blind -row $mitte -column 2 -sticky nsew
}

for { set index $mitte } { $index <= $anzahl_parameter } { incr index } {
  label .feld.titel$index
  button .feld.$index -width 20 -command "WaehleParameter $index"
  set zeile [ expr $index - $mitte + 1 ]
  grid .feld.titel$index -row $zeile -column 4 -sticky nsw
  grid .feld.$index      -row $zeile -column 3 -sticky nsew
  set status($index)    0
  set parameter($index) 0
}

entry .feld.eingabe -width 20 -state disabled

set sprache     1
set widerspruch 0

proc EnglischeTitel {} {
  global anzahl_parameter etitel titel

  for { set index 1 } { $index <= $anzahl_parameter } { incr index } {
    set titel($index) $etitel($index)
  }
}

proc DeutscheTitel {} {
  global anzahl_parameter dtitel titel

  for { set index 1 } { $index <= $anzahl_parameter } { incr index } {
    set titel($index) $dtitel($index)
  }
}

proc WechselDieSprache {} {
  global anzahl_parameter sprache titel

  if { $sprache > 0 } {
    set sprache 0
    EnglischeTitel
    .knopf.sprache configure -text "Radar-Systemparameter auf Deutsch"
  } else {
    set sprache 1
    DeutscheTitel
    .knopf.sprache configure -text "Radar-Systemparameter auf Englisch"
  }

  for { set index 1 } { $index <= $anzahl_parameter } { incr index } {
    .feld.titel$index configure -text $titel($index)
  }
}

WechselDieSprache

proc Nachkommawert { wert } {
  set wert [ format "%.4e" $wert ]
  return [ expr fmod ($wert, 1) ]
}

proc FormatiereWert { wert } {
  set wert [ format "%.4e" $wert ]

  if { $wert <= 1.0e6 } {
    if       { [ Nachkommawert                $wert   ] == 0.0 } {
      set wert [ format "%d" [ expr int ($wert) ] ]
    } elseif { [ Nachkommawert [ expr 1.0e1 * $wert ] ] == 0.0 } {
      set wert [ format "%3.1f" $wert ]
    } elseif { [ Nachkommawert [ expr 1.0e2 * $wert ] ] == 0.0 } {
      set wert [ format "%4.2f" $wert ]
    } elseif { [ Nachkommawert [ expr 1.0e3 * $wert ] ] == 0.0 } {
      set wert [ format "%5.3f" $wert ]
    } elseif { [ Nachkommawert [ expr 1.0e4 * $wert ] ] == 0.0 } {
      set wert [ format "%6.4f" $wert ]
    } elseif { [ Nachkommawert [ expr 1.0e5 * $wert ] ] == 0.0 } {
      set wert [ format "%7.5f" $wert ]
    } elseif { [ Nachkommawert [ expr 1.0e6 * $wert ] ] == 0.0 } {
      set wert [ format "%8.6f" $wert ]
    }
  }

  return $wert
}

proc SetzeParameter { index wert } {
  global parameter

  if [ catch { set dummy [ expr $wert ] } ] {
    set parameter($index) [ format "%.4e" $wert ]
  } else {
    set parameter($index) $wert
  }

  set wert [ FormatiereWert $wert ]
  .feld.$index configure -text "$wert"
}

set status(27) 1
SetzeParameter 27 90

proc ErgaenzeParameter { index wert } {
  global status

  set status($index) -1
  SetzeParameter $index $wert
  .feld.$index configure -fg red -activeforeground red
}

proc PruefeParameter { index wert } {
  global status parameter widerspruch

  if { [ FormatiereWert $parameter($index) ] != [ FormatiereWert $wert ] } {
    if { $status($index) > 0 } {
      .feld.$index configure -fg sienna -activeforeground sienna
      set widerspruch 1
    } else {
      SetzeParameter $index $wert
    }
  }
}

proc PruefeSchielwinkel {} {
  global status parameter

  if { $status(27) != 0 } {
    if { $parameter(27) > 180.0 } {
      SetzeParameter 27 180.0
    }

    if { $status(9) != 0 } {
      set wert [ expr $parameter(9) / 2.0 ]
      if { $parameter(27) < $wert } {
        PruefeParameter 27 $wert
      }

      set wert [ expr 180.0 - $parameter(9) / 2.0 ]
      if { $parameter(27) > $wert } {
        PruefeParameter 27 $wert
      }
    }
  }
}

proc BerechneParameter {} {
  global status parameter

  set c 3.0e8
  set degtorad [ expr 3.14159265358979323846 / 180.0 ]

#  $$ \Delta {\sf CR} = \frac{\lambda}{2 \cdot \Omega} $$
#  1: Wellenlänge [mm]
#  7: Beobachtungswinkel [Grad]
# 22: Größe eines Querrichtungstors (Dopplerzelle) [m]
  if { [ expr abs ($status(1)) + abs ($status(7)) + abs ($status(22)) ] == 2 } {
    if { $status(1) == 0 } {
      ErgaenzeParameter 1 \
        [ expr 2.0 * ($parameter(7) * $degtorad) * $parameter(22) / 1.0e-3 ]
    }
    if { $status(7) == 0 } {
      ErgaenzeParameter 7 \
        [ expr ($parameter(1) * 1.0e-3) / 2.0 / $parameter(22) / $degtorad ]
    }
    if { $status(22) == 0 } {
      ErgaenzeParameter 22 \
        [ expr ($parameter(1) * 1.0e-3) / 2.0 / ($parameter(7) * $degtorad) ]
    }
  }

  if { [ expr abs ($status(1)) + abs ($status(7)) + abs ($status(22)) ] == 3 } {
    PruefeParameter 7 \
      [ expr ($parameter(1) * 1.0e-3) / 2.0 / $parameter(22) / $degtorad ]
  }

#  $$ \Omega = \frac{L}{R} $$
#  6: Effektive Länge der synthetischen Apertur [m]
#  7: Beobachtungswinkel [Grad]
# 15: Zielentfernung [km]
  if { [ expr abs ($status(6)) + abs ($status(7)) + abs ($status(15)) ] == 2 } {
    if { $status(6) == 0 } {
      ErgaenzeParameter 6 \
        [ expr ($parameter(7) * $degtorad) * ($parameter(15) * 1.0e3) ]
    }
    if { $status(7) == 0 } {
      ErgaenzeParameter 7 \
        [ expr $parameter(6) / ($parameter(15) * 1.0e3) / $degtorad ]
    }
    if { $status(15) == 0 } {
      ErgaenzeParameter 15 \
        [ expr $parameter(6) / ($parameter(7) * $degtorad) / 1.0e3 ]
    }
  }

  if { [ expr abs ($status(6)) + abs ($status(7)) + abs ($status(15)) ] == 3 } {
    PruefeParameter 6 \
      [ expr ($parameter(7) * $degtorad) * ($parameter(15) * 1.0e3) ]
  }

#  $$ L = v \cdot T \cdot \sin (\psi) $$
#  5: Kohärente Zielbeobachtungszeit [s]
#  6: Effektive Länge der synthetischen Apertur [m]
# 16: Geschwindigkeit der Sensorplattform [m/s]
# 27: Keulensteuerwinkel relativ zur Geschwindigkeit [Grad]
  PruefeSchielwinkel
  if { [ expr abs ($status(5))  + abs ($status(6)) + \
              abs ($status(16)) + abs ($status(27)) ] == 3 } {
    if { $status(5) == 0 } {
      ErgaenzeParameter 5 \
        [ expr $parameter(6) / \
               $parameter(16) / sin ($parameter(27) * $degtorad) ]
    }
    if { $status(6) == 0 } {
      ErgaenzeParameter 6 \
        [ expr $parameter(5) * $parameter(16) * \
               sin ($parameter(27) * $degtorad) ]
    }
    if { $status(16) == 0 } {
      ErgaenzeParameter 16 \
        [ expr $parameter(6) / \
               $parameter(5) / sin ($parameter(27) * $degtorad) ]
    }
    if { $status(27) == 0 } {
      set maximum [ expr 1.0 * $parameter(5) * $parameter(16) ]
      if { $parameter(6) > $maximum } {
        PruefeParameter 6 $maximum
      }
      if { $parameter(6) <= $maximum } {
        set wert [ expr asin ($parameter(6) / $maximum) / $degtorad ]
        ErgaenzeParameter 27 $wert
        PruefeSchielwinkel
        if { $parameter(27) > $wert } {
          PruefeParameter 5 \
            [ expr $parameter(6) / \
                   $parameter(16) / sin ($parameter(27) * $degtorad) ]
        }
      }
    }
  }

  if { [ expr abs ($status(5))  + abs ($status(6)) + \
              abs ($status(16)) + abs ($status(27)) ] == 4 } {
    PruefeParameter 5 \
      [ expr $parameter(6) / $parameter(16) / sin ($parameter(27) * $degtorad) ]
  }

#  $$ n_{\sf d} = T \cdot {\sf PRF} $$
#  4: Impulsfolgefrequenz [Hz]
#  5: Kohärente Zielbeobachtungszeit [s]
# 25: Anzahl Dopplerzellen (Impulse)
  if { [ expr abs ($status(4)) + abs ($status(5)) + abs ($status(25)) ] == 2 } {
    if { $status(4) == 0 } {
      ErgaenzeParameter 4 [ expr 1.0 * $parameter(25) / $parameter(5) ]
    }
    if { $status(5) == 0 } {
      ErgaenzeParameter 5 [ expr 1.0 * $parameter(25) / $parameter(4) ]
    }
    if { $status(25) == 0 } {
      ErgaenzeParameter 25 [ expr $parameter(4) * $parameter(5) ]
    }
  }

  if { [ expr abs ($status(4)) + abs ($status(5)) + abs ($status(25)) ] == 3 } {
    PruefeParameter 4 [ expr 1.0 * $parameter(25) / $parameter(5) ]
  }

#  $$ \lambda = \frac{c}{f} $$
#  1: Wellenlänge [mm]
#  2: Trägerfrequenz [GHz]
  if { [ expr abs ($status(1)) + abs ($status(2)) ] == 1 } {
    if { $status(1) == 0 } {
      ErgaenzeParameter 1 [ expr $c / ($parameter(2) * 1.0e9) / 1.0e-3 ]
    }
    if { $status(2) == 0 } {
      ErgaenzeParameter 2 [ expr $c / ($parameter(1) * 1.0e-3) / 1.0e9 ]
    }
  }

  if { [ expr abs ($status(1)) + abs ($status(2)) ] == 2 } {
    PruefeParameter 2 [ expr $c / ($parameter(1) * 1.0e-3) / 1.0e9 ]
  }

#  $$ \theta_{\sf 3dB} = \frac{\lambda}{D} $$
#  1: Wellenlänge [mm]
#  8: Aperturabmessung in Azimut [m]
#  9: Antennenkeulenhalbwertsbreite in Azimut [Grad]
  if { [ expr abs ($status(1)) + abs ($status(8)) + abs ($status(9)) ] == 2 } {
    if { $status(1) == 0 } {
      ErgaenzeParameter 1 \
        [ expr $parameter(8) * ($parameter(9) * $degtorad) / 1.0e-3 ]
    }
    if { $status(8) == 0 } {
      ErgaenzeParameter 8 \
        [ expr ($parameter(1) * 1.0e-3) / ($parameter(9) * $degtorad) ]
    }
    if { $status(9) == 0 } {
      ErgaenzeParameter 9 \
        [ expr ($parameter(1) * 1.0e-3) / $parameter(8) / $degtorad ]
    }
  }

  if { [ expr abs ($status(1)) + abs ($status(8)) + abs ($status(9)) ] == 3 } {
    PruefeParameter 8 \
      [ expr ($parameter(1) * 1.0e-3) / ($parameter(9) * $degtorad) ]
  }

#  $$ R_{\sf eindeutig} = \frac{c}{2 \cdot {\sf PRF}} $$
#  4: Impulsfolgefrequenz [Hz]
# 18: Eindeutige Reichweite [km]
  if { [ expr abs ($status(4)) + abs ($status(18)) ] == 1 } {
    if { $status(4) == 0 } {
      ErgaenzeParameter 4 [ expr $c / 2.0 / ($parameter(18) * 1.0e3) ]
    }
    if { $status(18) == 0 } {
      ErgaenzeParameter 18 [ expr $c / 2.0 / $parameter(4) / 1.0e3 ]
    }
  }

  if { [ expr abs ($status(4)) + abs ($status(18)) ] == 2 } {
    PruefeParameter 18 [ expr $c / 2.0 / $parameter(4) / 1.0e3 ]
  }

#  $$ v_{\sf eindeutig} = \frac{\lambda \cdot {\sf PRF}}{2} $$
#  1: Wellenlänge [mm]
#  4: Impulsfolgefrequenz [Hz]
# 20: Eindeutiger Geschwindigkeitsbereich [m/s]
  if { [ expr abs ($status(1)) + abs ($status(4)) + abs ($status(20)) ] == 2 } {
    if { $status(1) == 0 } {
      ErgaenzeParameter 1 [ expr 2.0 * $parameter(20) / $parameter(4) / 1.0e-3 ]
    }
    if { $status(4) == 0 } {
      ErgaenzeParameter 4 \
        [ expr 2.0 * $parameter(20) / ($parameter(1) * 1.0e-3) ]
    }
    if { $status(20) == 0 } {
      ErgaenzeParameter 20 \
        [ expr ($parameter(1) * 1.0e-3) * $parameter(4) / 2.0 ]
    }
  }

  if { [ expr abs ($status(1)) + abs ($status(4)) + abs ($status(20)) ] == 3 } {
    PruefeParameter 20 [ expr ($parameter(1) * 1.0e-3) * $parameter(4) / 2.0 ]
  }

#  $$ \Delta R = \frac{c}{2 \cdot B} $$
#  3: Signalbandbreite [MHz]
# 21: Größe eines Entfernungstors [m]
  if { [ expr abs ($status(3)) + abs ($status(21)) ] == 1 } {
    if { $status(3) == 0 } {
      ErgaenzeParameter 3 [ expr $c / 2.0 / $parameter(21) / 1.0e6 ]
    }
    if { $status(21) == 0 } {
      ErgaenzeParameter 21 [ expr $c / 2.0 / ($parameter(3) * 1.0e6) ]
    }
  }

  if { [ expr abs ($status(3)) + abs ($status(21)) ] == 2 } {
    PruefeParameter 21 [ expr $c / 2.0 / ($parameter(3) * 1.0e6) ]
  }

#  $$ \Delta v = \frac{\lambda}{2 \cdot T} $$
#  1: Wellenlänge [mm]
#  5: Kohärente Zielbeobachtungszeit [s]
# 23: Größe eines Geschwindigkeitstors (Dopplerzelle) [m/s]
  if { [ expr abs ($status(1)) + abs ($status(5)) + abs ($status(23)) ] == 2 } {
    if { $status(1) == 0 } {
      ErgaenzeParameter 1 [ expr 2.0 * $parameter(5) * $parameter(23) / 1.0e-3 ]
    }
    if { $status(5) == 0 } {
      ErgaenzeParameter 5 \
        [ expr ($parameter(1) * 1.0e-3) / 2.0 / $parameter(23) ]
    }
    if { $status(23) == 0 } {
      ErgaenzeParameter 23 \
        [ expr ($parameter(1) * 1.0e-3) / 2.0 / $parameter(5) ]
    }
  }

  if { [ expr abs ($status(1)) + abs ($status(5)) + abs ($status(23)) ] == 3 } {
    PruefeParameter 23 [ expr ($parameter(1) * 1.0e-3) / 2.0 / $parameter(5) ]
  }

#  $$ n_{\sf r} = \frac{B}{\sf PRF} $$
#  3: Signalbandbreite [MHz]
#  4: Impulsfolgefrequenz [Hz]
# 24: Maximale Anzahl Entfernungstore
  if { [ expr abs ($status(3)) + abs ($status(4)) + abs ($status(24)) ] == 2 } {
    if { $status(3) == 0 } {
      ErgaenzeParameter 3 [ expr $parameter(4) * $parameter(24) / 1.0e6 ]
    }
    if { $status(4) == 0 } {
      ErgaenzeParameter 4 [ expr ($parameter(3) * 1.0e6) / $parameter(24) ]
    }
    if { $status(24) == 0 } {
      ErgaenzeParameter 24 [ expr ($parameter(3) * 1.0e6) / $parameter(4) ]
    }
  }

  if { [ expr abs ($status(3)) + abs ($status(4)) + abs ($status(24)) ] == 3 } {
    PruefeParameter 24 [ expr ($parameter(3) * 1.0e6) / $parameter(4) ]
  }

#  $$ n_{\sf d} = \frac{{\sf CR}_{\sf eindeutig}}{\Delta {\sf CR}} $$
# 19: Eindeutiger Querrichtungsbereich [m]
# 22: Größe eines Querrichtungstors (Dopplerzelle) [m]
# 25: Anzahl Dopplerzellen (Impulse)
  if { \
    [ expr abs ($status(19)) + abs ($status(22)) + abs ($status(25)) ] == 2 } {
    if { $status(19) == 0 } {
      ErgaenzeParameter 19 [ expr $parameter(22) * $parameter(25) ]
    }
    if { $status(22) == 0 } {
      ErgaenzeParameter 22 [ expr 1.0 * $parameter(19) / $parameter(25) ]
    }
    if { $status(25) == 0 } {
      ErgaenzeParameter 25 [ expr 1.0 * $parameter(19) / $parameter(22) ]
    }
  }

  if { \
    [ expr abs ($status(19)) + abs ($status(22)) + abs ($status(25)) ] == 3 } {
    PruefeParameter 19 [ expr $parameter(22) * $parameter(25) ]
  }

#  $$ R_{\sf min} = \frac{c \cdot \tau}{2} $$
# 13: Impulsdauer [us]
# 17: Minimalentfernung [m]
  if { [ expr abs ($status(13)) + abs ($status(17)) ] == 1 } {
    if { $status(13) == 0 } {
      ErgaenzeParameter 13 [ expr 2.0 * $parameter(17) / $c / 1.0e-6 ]
    }
    if { $status(17) == 0 } {
      ErgaenzeParameter 17 [ expr $c * ($parameter(13) * 1.0e-6) / 2.0 ]
    }
  }

  if { [ expr abs ($status(13)) + abs ($status(17)) ] == 2 } {
    PruefeParameter 17 [ expr $c * ($parameter(13) * 1.0e-6) / 2.0 ]
  }

#  $$ T_{\sf s} = T \cdot \frac{\Delta\alpha}{\theta_{\sf 3dB}} $$
#  5: Kohärente Zielbeobachtungszeit [s]
#  9: Antennenkeulenhalbwertsbreite in Azimut [Grad]
# 10: Azimutsektorgröße [Grad]
# 11: Absuchdauer pro Azimutsektor [s]
  if { [ expr abs ($status(5))  + abs ($status(9)) + \
              abs ($status(10)) + abs ($status(11)) ] == 3 } {
    if { $status(5) == 0 } {
      ErgaenzeParameter 5 \
        [ expr 1.0 * $parameter(9) * $parameter(11) / $parameter(10) ]
    }
    if { $status(9) == 0 } {
      ErgaenzeParameter 9 \
        [ expr 1.0 * $parameter(5) * $parameter(10) / $parameter(11) ]
    }
    if { $status(10) == 0 } {
      ErgaenzeParameter 10 \
        [ expr 1.0 * $parameter(9) * $parameter(11) / $parameter(5) ]
    }
    if { $status(11) == 0 } {
      ErgaenzeParameter 11 \
        [ expr 1.0 * $parameter(5) * $parameter(10) / $parameter(9) ]
    }
  }

  if { [ expr abs ($status(5))  + abs ($status(9)) + \
              abs ($status(10)) + abs ($status(11)) ] == 4 } {
    PruefeParameter 11 \
      [ expr 1.0 * $parameter(5) * $parameter(10) / $parameter(9) ]
  }

#  $$ \gamma_{\sf S/N} = 10 \cdot \log_{10} (n_{\sf d}) $$
# 25: Anzahl Dopplerzellen (Impulse)
# 26: Maximaler S/N-Gewinn durch Doppler-FFT [dB]
  if { $status(26) != 0 } {
    if { $parameter(26) > 90.0 } {
      SetzeParameter 26 90.0
    }
  }
  if { [ expr abs ($status(25)) + abs ($status(26)) ] == 1 } {
    if { $status(25) == 0 } {
      ErgaenzeParameter 25 [ expr pow (10.0, ($parameter(26) / 10.0)) ]
    }
    if { $status(26) == 0 } {
      ErgaenzeParameter 26 [ expr 10.0 * log10 ($parameter(25)) ]
    }
  }

  if { [ expr abs ($status(25)) + abs ($status(26)) ] == 2 } {
    PruefeParameter 26 [ expr 10.0 * log10 ($parameter(25)) ]
  }

#  $$ n_{\sf clutter} = \frac{2 \cdot L}{D} $$
#  6: Effektive Länge der synthetischen Apertur [m]
#  8: Aperturabmessung in Azimut [m]
# 28: Anzahl Dopplerzellen mit Bodenechos
  if { [ expr abs ($status(6)) + abs ($status(8)) + abs ($status(28)) ] == 2 } {
    if { $status(6) == 0 } {
      ErgaenzeParameter 6 [ expr $parameter(8) * $parameter(28) / 2.0 ]
    }
    if { $status(8) == 0 } {
      ErgaenzeParameter 8 [ expr 2.0 * $parameter(6) / $parameter(28) ]
    }
    if { $status(28) == 0 } {
      ErgaenzeParameter 28 [ expr 2.0 * $parameter(6) / $parameter(8) ]
    }
  }

  if { [ expr abs ($status(6)) + abs ($status(8)) + abs ($status(28)) ] == 3 } {
    PruefeParameter 28 [ expr 2.0 * $parameter(6) / $parameter(8) ]
  }

#  $$ \tau = \frac{K}{B} $$
#  3: Signalbandbreite [MHz]
# 12: Impulskompressionsfaktor
# 13: Impulsdauer [us]
  if { \
    [ expr abs ($status(3)) + abs ($status(12)) + abs ($status(13)) ] == 2 } {
    if { $status(3) == 0 } {
      ErgaenzeParameter 3 \
        [ expr $parameter(12) / ($parameter(13) * 1.0e-6) / 1.0e6 ]
    }
    if { $status(12) == 0 } {
      ErgaenzeParameter 12 \
        [ expr ($parameter(3) * 1.0e6) * ($parameter(13) * 1.0e-6) ]
    }
    if { $status(13) == 0 } {
      ErgaenzeParameter 13 \
        [ expr $parameter(12) / ($parameter(3) * 1.0e6) / 1.0e-6 ]
    }
  }

  if { \
    [ expr abs ($status(3)) + abs ($status(12)) + abs ($status(13)) ] == 3 } {
    PruefeParameter 12 \
      [ expr ($parameter(3) * 1.0e6) * ($parameter(13) * 1.0e-6) ]
  }

#  $$ \eta = \tau \cdot {\sf PRF} $$
#  4: Impulsfolgefrequenz [Hz]
# 13: Impulsdauer [us]
# 14: Tastverhältnis [%]
  if { \
    [ expr abs ($status(4)) + abs ($status(13)) + abs ($status(14)) ] == 2 } {
    if { $status(4) == 0 } {
      ErgaenzeParameter 4 \
        [ expr ($parameter(14) * 1.0e-2) / ($parameter(13) * 1.0e-6) ]
    }
    if { $status(13) == 0 } {
      ErgaenzeParameter 13 \
        [ expr ($parameter(14) * 1.0e-2) / $parameter(4) / 1.0e-6 ]
    }
    if { $status(14) == 0 } {
      ErgaenzeParameter 14 \
        [ expr $parameter(4) * ($parameter(13) * 1.0e-6) / 1.0e-2 ]
    }
  }

  if { \
    [ expr abs ($status(4)) + abs ($status(13)) + abs ($status(14)) ] == 3 } {
    PruefeParameter 14 \
      [ expr $parameter(4) * ($parameter(13) * 1.0e-6) / 1.0e-2 ]
  }
}

proc AktualisiereFelder { neu } {
  global anzahl_gleichungen anzahl_parameter status parameter widerspruch

  set anzahl 0

  for { set index 1 } { $index <= $anzahl_parameter } { incr index } {
    if { $status($index) < 0 } {
      set status($index)    0
      set parameter($index) 0
      .feld.$index configure -text "" -fg black -activeforeground black
    }
    if { $status($index) > 0 } {
      incr anzahl
    }
  }

  set widerspruch 0

  for { set index 1 } { $index <= $anzahl_gleichungen } { incr index } {
    BerechneParameter
  }

  if { $anzahl > 0 } {
    .knopf.neu configure -state normal
  } else {
    .knopf.neu configure -state disabled
  }

  if { $neu > 0 } {
    if { $widerspruch > 0 } {
      .feld.$neu configure -text "Wert führt zu Widerspruch!" \
        -fg sienna -activeforeground sienna
      set status($neu)    0
      set parameter($neu) 0
      AktualisiereFelder 0
    }
  }
}

proc LoescheParameter { index } {
  global status parameter

  .feld.$index configure -text "" -fg black -activeforeground black
  set status($index)    0
  set parameter($index) 0
  AktualisiereFelder 0
}

proc UebernehmeParameter { index } {
  global status parameter alt_index

  if { $alt_index > 0 } {
    set alt_index 0
    set wert [ .feld.eingabe get ]
    .feld.eingabe delete 0 end
    .feld.eingabe configure -state disabled

    if [ catch { set dummy [ format "%e" $wert ] } ] {
      LoescheParameter $index
    } else {
      if { $wert <= 0 } {
        LoescheParameter $index
      } else {
        set status($index) 1
        SetzeParameter $index $wert
        .feld.$index configure -fg black -activeforeground black
        AktualisiereFelder $index
      }
    }

    grid forget .feld.eingabe
    grid .feld.$index
  }
}

proc LoescheAlleParameter {} {
  global anzahl_parameter status alt_index

  UebernehmeParameter $alt_index

  for { set index 1 } { $index <= $anzahl_parameter } { incr index } {
    LoescheParameter $index
  }

  set status(27) 1
  SetzeParameter 27 90
}

proc LiesParameter {} {
  global anzahl_parameter sprache status parameter

  LoescheAlleParameter
  LoescheParameter 27

  set dateiname [ tk_getOpenFile \
    -defaultextension .rsd -filetypes { { Radar-Sudoku-Daten { .rsd .RSD } } } \
    -initialfile "" -parent . \
    -title "Dateiname zum Einlesen der Radar-Sudoku-Werte" ]

  if { [ string compare $dateiname "" ] } {
    set datei [ open "$dateiname" r ]
    gets $datei zeile
    set wert [ split $zeile " " ]
    if { [ lindex $wert 0 ] == 2017 } {
      if { [ lindex $wert 1 ] != $sprache } { WechselDieSprache }
      for { set index 1 } { $index <= $anzahl_parameter } { incr index } {
        gets $datei zeile
        set wert [ split $zeile " " ]
        if { [ lindex $wert 0 ] > 0 } {
          set status($index) 1
          SetzeParameter $index [ lindex $wert 1 ]
          AktualisiereFelder $index
        }
      }
    } else {
      close $datei
      set datei [ open "$dateiname" r ]
      foreach index {  1  2  3  4  5  6  7  8  9 10 11 12 17 \
                      15 16 18 19 20 21 22 23 24 25 26 27 28 } {
        gets $datei zeile
        set wert [ split $zeile " " ]
        if { [ lindex $wert 0 ] > 0 } {
          set status($index) 1
          SetzeParameter $index [ lindex $wert 1 ]
          AktualisiereFelder $index
        }
      }
    }
    close $datei
  }
}

proc SchreibeParameter {} {
  global anzahl_parameter sprache status parameter alt_index titel

  UebernehmeParameter $alt_index

  set dateiname [ tk_getSaveFile \
    -defaultextension .rsd -filetypes { { Radar-Sudoku-Daten { .rsd .RSD } } } \
    -initialfile "" -parent . \
    -title "Dateiname zum Abspeichern der Radar-Sudoku-Werte" ]

  if { [ string compare $dateiname "" ] } {
    set datei [ open "$dateiname" w ]
    puts $datei [ format "2017 %d" $sprache ]
    for { set index 1 } { $index <= $anzahl_parameter } { incr index } {
      puts $datei [ format "%02d %-20s %s" \
        $status($index) $parameter($index) $titel($index) ]
    }
    close $datei
  }
}

proc NichtDruecken {} {
  global anzahl_parameter alt_index

  UebernehmeParameter $alt_index

  for { set index 1 } { $index <= $anzahl_parameter } { incr index } {
    .feld.$index configure -state disabled
  }

  .knopf.neu configure -state disabled
  .knopf.lesen configure -state disabled
  .knopf.schreiben configure -state disabled
  .knopf.sprache configure -state disabled
  .knopf.nicht configure -state disabled
  .knopf.ende configure -state disabled

  set antwort [ tk_messageBox -icon warning -title "Festplatte formatieren" \
    -message "Die Festplatte wird nun formatiert!" -type okcancel ]

  if { $antwort != "ok" } {
    set antwort [ tk_messageBox -icon warning -title "Honorar überweisen" \
      -message "100 Euro an die Autoren überweisen!" ]
  }
}

proc WaehleParameter { index } {
  global mitte status parameter alt_index titel

  UebernehmeParameter $alt_index

  if { $status($index) > -1 } {
    set alt_index $index

    grid remove .feld.$index
    if { $index < $mitte } {
      grid .feld.eingabe -row $index -column 2 -sticky nsew
    } else {
      set zeile [ expr $index - $mitte + 1 ]
      grid .feld.eingabe -row $zeile -column 3 -sticky nsew
    }
    .feld.eingabe configure -state normal

    if { $status($index) > 0 } {
      .feld.eingabe insert 0 $parameter($index)
      .feld.eingabe selection range 0 end
    }

    bind .feld.eingabe <Return>   "UebernehmeParameter $index"
    bind .feld.eingabe <KP_Enter> "UebernehmeParameter $index"

    focus .feld.eingabe
  }
}