# Gleichungen Förderer aufwärts

![Varioförderer aufwärts](bilder/Variofoerderer_aufwaerts.svg)
**violett** ist F wie _Förderer_
**hellblau** ist S wie _Strecke_
**AS** ist _Ausschleus_- Element
**ES** ist _Einschleus_- Element


## Gegeben

$H_0$, $H_1$, $L_1$, $\alpha_F$, $\alpha_S$, $L_{ES}$, $H_{ES}$, $L_{AS}$, $H_{AS}$

## Gesucht

$L_F$, $L_S$, $H_F$, $H_S$

---

## Grundgleichungen ($H_1 > H_0$, Förderrichtung: von $H_0$ nach $H_1$)

**(1) Horizontal:**

$$L_1 = L_{ES} + L_F + L_S + L_{AS}$$

**(2) Vertikal:**

$$H_1 - H_0 = H_F - H_S - H_{ES} - H_{AS}$$

**(3) Neigung F:**

$$\tan(\alpha_F) = \frac{H_F}{L_F} \quad \Rightarrow \quad H_F = L_F \cdot \tan(\alpha_F)$$

**(4) Neigung S:**

$$\tan(\alpha_S) = \frac{H_S}{L_S} \quad \Rightarrow \quad H_S = L_S \cdot \tan(\alpha_S)$$

---

## Lösung (Einsetzen von (3),(4) in (1),(2))

**(I)**

$$L_F + L_S = L_1 - L_{ES} - L_{AS}$$

**(II)**

$$L_F \cdot \tan(\alpha_F) - L_S \cdot \tan(\alpha_S) = (H_1 - H_0) + H_{ES} + H_{AS}$$

---

## Ergebnis

$$L_F = \frac{(H_1 - H_0 + H_{ES} + H_{AS}) + (L_1 - L_{ES} - L_{AS}) \cdot \tan(\alpha_S)}{\tan(\alpha_F) + \tan(\alpha_S)}$$

$$L_S = (L_1 - L_{ES} - L_{AS}) - L_F$$

$$H_F = L_F \cdot \tan(\alpha_F)$$

$$H_S = L_S \cdot \tan(\alpha_S)$$


# Gleichungen Förderer abwärts

![Varioförderer abwärts](bilder/Variofoerderer_abwaerts.svg)

## Gegeben

$H_0$, $H_1$, $L_1$, $\alpha_F$, $\alpha_S$, $L_{ES}$, $H_{ES}$, $L_{AS}$, $H_{AS}$

## Gesucht

$L_F$, $L_S$, $H_F$, $H_S$

---

## Grundgleichungen ($H_0 > H_1$, Förderrichtung: von $H_0$ nach $H_1$)

**(1) Horizontal:**

$$L_1 = L_{ES} + L_F + L_S + L_{AS}$$

**(2) Vertikal:**

$$H_0 - H_1 = H_{ES} + H_F + H_S + H_{AS}$$

**(3) Neigung F:**

$$\tan(\alpha_F) = \frac{H_F}{L_F} \quad \Rightarrow \quad H_F = L_F \cdot \tan(\alpha_F)$$

**(4) Neigung S:**

$$\tan(\alpha_S) = \frac{H_S}{L_S} \quad \Rightarrow \quad H_S = L_S \cdot \tan(\alpha_S)$$

---

## Lösung (Einsetzen von (3),(4) in (1),(2))

**(I)**

$$L_F + L_S = L_1 - L_{ES} - L_{AS}$$

**(II)**

$$L_F \cdot \tan(\alpha_F) + L_S \cdot \tan(\alpha_S) = (H_0 - H_1) - H_{ES} - H_{AS}$$

---

## Ergebnis

$$L_F = \frac{(H_0 - H_1 - H_{ES} - H_{AS}) - (L_1 - L_{ES} - L_{AS}) \cdot \tan(\alpha_S)}{\tan(\alpha_F) - \tan(\alpha_S)}$$

$$L_S = (L_1 - L_{ES} - L_{AS}) - L_F$$

$$H_F = L_F \cdot \tan(\alpha_F)$$

$$H_S = L_S \cdot \tan(\alpha_S)$$

# Zusammenfassung

Wobei $\alpha_S$ normalerweise immer bei 3° liegt und $\alpha_F$ von 3,6,9,12,15.. 51°  läuft.

```python
#!/usr/bin/env python3
"""
Förderer-Berechnung in 2D – beide Fälle
====================================================
Aufwärts (H1 > H0):
  ΔH = H1 - H0
  L_F = (ΔH + H_ES + H_AS + L_rest·tan(α_S)) / (tan(α_F) + tan(α_S))
  Probe: H_F - H_S - H_ES - H_AS = ΔH

Abwärts (H0 > H1):
  ΔH = H0 - H1
  L_F = (ΔH - H_ES - H_AS - L_rest·tan(α_S)) / (tan(α_F) - tan(α_S))
  Probe: H_ES + H_F + H_S + H_AS = ΔH
"""

import math

# ============================================================
# KONSTANTEN [alle in Meter / Grad]
# ============================================================
H0   = 2.0
H1   = 5.0
L1   = 8.0
L_ES = 1.0
H_ES = 0.3
L_AS = 1.0
H_AS = 0.3

ALPHA_S = 3.0
ALPHA_F_LIST = [3, 6, 9, 12, 15, 18, 24, 27, 33, 39, 45, 51]


def berechne(h0, h1, l1, l_es, h_es, l_as, h_as, alpha_f_deg, alpha_s_deg):
    """
    Berechnet L_F, L_S, H_F, H_S.
    Unterscheidet automatisch aufwärts/abwärts anhand h0 vs h1.
    """
    alpha_f = math.radians(alpha_f_deg)
    alpha_s = math.radians(alpha_s_deg)
    tan_f = math.tan(alpha_f)
    tan_s = math.tan(alpha_s)
    l_rest = l1 - l_es - l_as

    if h1 >= h0:
        # === AUFWÄRTS ===
        # (2): H1 - H0 = H_F - H_S - H_ES - H_AS
        delta_h = h1 - h0
        nenner = tan_f + tan_s
        if abs(nenner) < 1e-12:
            return None
        zaehler = (delta_h + h_es + h_as) + l_rest * tan_s
        fall = "aufwärts"
    else:
        # === ABWÄRTS ===
        # (2): H0 - H1 = H_ES + H_F + H_S + H_AS
        delta_h = h0 - h1
        nenner = tan_f - tan_s
        if abs(nenner) < 1e-12:
            return None
        zaehler = (delta_h - h_es - h_as) - l_rest * tan_s
        fall = "abwärts"

    l_f = zaehler / nenner
    l_s = l_rest - l_f
    h_f = l_f * tan_f
    h_s = l_s * tan_s

    # Gegenprobe
    if fall == "aufwärts":
        probe = h_f - h_s - h_es - h_as  # soll = H1-H0
    else:
        probe = h_es + h_f + h_s + h_as   # soll = H0-H1

    return {
        "L_F": l_f, "L_S": l_s,
        "H_F": h_f, "H_S": h_s,
        "fall": fall, "delta_h": delta_h, "probe": probe,
    }


def validierung(erg):
    probleme = []
    for key in ("L_F", "L_S", "H_F", "H_S"):
        if erg[key] < 0:
            probleme.append(f"{key} < 0")
    # L_F und L_S dürfen auch nicht > L_rest sein (implizit durch L_S < 0)
    return (len(probleme) == 0, probleme)


def md_tabelle(fall_name, h0_val, h1_val):
    """Erzeugt Markdown-Tabelle. Fall wird aus h0/h1 abgeleitet."""
    l_rest = L1 - L_ES - L_AS
    delta_h = abs(h1_val - h0_val)
    richtung = "aufwärts" if h1_val >= h0_val else "abwärts"

    lines = []
    lines.append(f"### {fall_name}")
    lines.append(f"H₀ = {h0_val:.3f} m, H₁ = {h1_val:.3f} m → **{richtung}**, "
                 f"ΔH = {delta_h:.4f} m, L_rest = {l_rest:.3f} m\n")

    if richtung == "aufwärts":
        lines.append("Formel: L_F = (ΔH + H_ES + H_AS + L_rest·tan α_S) / "
                      "(tan α_F **+** tan α_S)")
        lines.append("")
        lines.append("Probe: H_F − H_S − H_ES − H_AS = ΔH\n")
    else:
        lines.append("Formel: L_F = (ΔH − H_ES − H_AS − L_rest·tan α_S) / "
                      "(tan α_F **−** tan α_S)")
        lines.append("")
        lines.append("Probe: H_ES + H_F + H_S + H_AS = ΔH\n")

    lines.append("| α_F [°] | L_F [m] | L_S [m] | H_F [m] | H_S [m] | Probe | Status |")
    lines.append("|--------:|--------:|--------:|--------:|--------:|------:|--------|")

    for alpha_f_deg in ALPHA_F_LIST:
        erg = berechne(h0_val, h1_val, L1, L_ES, H_ES, L_AS, H_AS,
                       alpha_f_deg, ALPHA_S)
        if erg is None:
            lines.append(f"| {alpha_f_deg} | — | — | — | — | — | ⚠ Nenner = 0 |")
            continue

        gueltig, probleme = validierung(erg)
        status = "✓ gültig" if gueltig else f"✗ {', '.join(probleme)}"

        lines.append(
            f"| {alpha_f_deg} "
            f"| {erg['L_F']:.4f} "
            f"| {erg['L_S']:.4f} "
            f"| {erg['H_F']:.4f} "
            f"| {erg['H_S']:.4f} "
            f"| {erg['probe']:.4f} "
            f"| {status} |"
        )
    lines.append("")
    return "\n".join(lines)


def grenzen():
    """Erzeugt Übersichtstabellen: für welche (ΔH, L1) Kombinationen
    existieren gültige Lösungen? Zeigt den kleinsten gültigen α_F.
    ΔH von 0..5 m, L1 von 3..15 m."""
    delta_h_list = [0, 1, 2, 3, 4, 5]
    l1_list = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
    lines = []

    for richtung in ("aufwärts", "abwärts"):
        lines.append(f"### {richtung.capitalize()}\n")
        lines.append("Zelle = kleinster gültiger α_F [°], "
                      "**—** = keine Lösung\n")

        # Header
        header = "| ΔH \\ L₁ |" + "|".join(f" {l1} m " for l1 in l1_list) + "|"
        sep = "|--------:|" + "|".join("------:" for _ in l1_list) + "|"
        lines.append(header)
        lines.append(sep)

        for dh in delta_h_list:
            if richtung == "aufwärts":
                h0, h1 = 0, dh
            else:
                h0, h1 = dh, 0

            row = f"| {dh} m |"
            for l1 in l1_list:
                min_alpha = None
                for alpha_f_deg in ALPHA_F_LIST:
                    erg = berechne(h0, h1, l1, L_ES, H_ES, L_AS, H_AS,
                                   alpha_f_deg, ALPHA_S)
                    if erg is not None:
                        gueltig, _ = validierung(erg)
                        if gueltig:
                            min_alpha = alpha_f_deg
                            break
                if min_alpha is not None:
                    row += f" {min_alpha}° |"
                else:
                    row += " — |"
            lines.append(row)
        lines.append("")
    return "\n".join(lines)


def main():
    md = []
    md.append("# Förderer-Berechnung (2D-Modell)\n")

    md.append("## Gegebene Werte\n")
    md.append("| Parameter | Wert |")
    md.append("|-----------|-----:|")
    md.append(f"| H₀ | {H0:.3f} m |")
    md.append(f"| H₁ | {H1:.3f} m |")
    md.append(f"| L₁ | {L1:.3f} m |")
    md.append(f"| L_ES | {L_ES:.3f} m |")
    md.append(f"| H_ES | {H_ES:.3f} m |")
    md.append(f"| L_AS | {L_AS:.3f} m |")
    md.append(f"| H_AS | {H_AS:.3f} m |")
    md.append(f"| α_S | {ALPHA_S:.1f}° |")
    md.append("")

    md.append("## Ergebnisse\n")

    # Fall 1: Aufwärts – H0=2 → H1=5
    md.append(md_tabelle("Fall 1: Aufwärts", h0_val=H0, h1_val=H1))

    # Fall 2: Abwärts – H0=5 → H1=2 (vertauscht!)
    md.append(md_tabelle("Fall 2: Abwärts", h0_val=H1, h1_val=H0))

    md.append("## Grenzen der Varianten\n")
    md.append(grenzen())

    result = "\n".join(md)
    print(result)

if __name__ == "__main__":
    main()
 ```
# Förderer-Berechnung (2D-Modell)

## Gegebene Werte

| Parameter | Wert |
|-----------|-----:|
| H₀ | 2.000 m |
| H₁ | 5.000 m |
| L₁ | 8.000 m |
| L_ES | 1.000 m |
| H_ES | 0.300 m |
| L_AS | 1.000 m |
| H_AS | 0.300 m |
| α_S | 3.0° |

## Ergebnisse

### Fall 1: Aufwärts
H₀ = 2.000 m, H₁ = 5.000 m → **aufwärts**, ΔH = 3.0000 m, L_rest = 6.000 m

Formel: L_F = (ΔH + H_ES + H_AS + L_rest·tan α_S) / (tan α_F **+** tan α_S)

Probe: H_F − H_S − H_ES − H_AS = ΔH

| α_F [°] | L_F [m] | L_S [m] | H_F [m] | H_S [m] | Probe | Status |
|--------:|--------:|--------:|--------:|--------:|------:|--------|
| 3 | 37.3460 | -31.3460 | 1.9572 | -1.6428 | 3.0000 | ✗ L_S < 0, H_S < 0 |
| 6 | 24.8517 | -18.8517 | 2.6120 | -0.9880 | 3.0000 | ✗ L_S < 0, H_S < 0 |
| 9 | 18.5702 | -12.5702 | 2.9412 | -0.6588 | 3.0000 | ✗ L_S < 0, H_S < 0 |
| 12 | 14.7735 | -8.7735 | 3.1402 | -0.4598 | 3.0000 | ✗ L_S < 0, H_S < 0 |
| 15 | 12.2190 | -6.2190 | 3.2741 | -0.3259 | 3.0000 | ✗ L_S < 0, H_S < 0 |
| 18 | 10.3741 | -4.3741 | 3.3708 | -0.2292 | 3.0000 | ✗ L_S < 0, H_S < 0 |
| 24 | 7.8661 | -1.8661 | 3.5022 | -0.0978 | 3.0000 | ✗ L_S < 0, H_S < 0 |
| 27 | 6.9660 | -0.9660 | 3.5494 | -0.0506 | 3.0000 | ✗ L_S < 0, H_S < 0 |
| 33 | 5.5776 | 0.4224 | 3.6221 | 0.0221 | 3.0000 | ✓ gültig |
| 39 | 4.5401 | 1.4599 | 3.6765 | 0.0765 | 3.0000 | ✓ gültig |
| 45 | 3.7195 | 2.2805 | 3.7195 | 0.1195 | 3.0000 | ✓ gültig |
| 51 | 3.0408 | 2.9592 | 3.7551 | 0.1551 | 3.0000 | ✓ gültig |

### Fall 2: Abwärts
H₀ = 5.000 m, H₁ = 2.000 m → **abwärts**, ΔH = 3.0000 m, L_rest = 6.000 m

Formel: L_F = (ΔH − H_ES − H_AS − L_rest·tan α_S) / (tan α_F **−** tan α_S)

Probe: H_ES + H_F + H_S + H_AS = ΔH

| α_F [°] | L_F [m] | L_S [m] | H_F [m] | H_S [m] | Probe | Status |
|--------:|--------:|--------:|--------:|--------:|------:|--------|
| 3 | — | — | — | — | — | ⚠ Nenner = 0 |
| 6 | 39.5767 | -33.5767 | 4.1597 | -1.7597 | 3.0000 | ✗ L_S < 0, H_S < 0 |
| 9 | 19.6794 | -13.6794 | 3.1169 | -0.7169 | 3.0000 | ✗ L_S < 0, H_S < 0 |
| 12 | 13.0226 | -7.0226 | 2.7680 | -0.3680 | 3.0000 | ✗ L_S < 0, H_S < 0 |
| 15 | 9.6759 | -3.6759 | 2.5926 | -0.1926 | 3.0000 | ✗ L_S < 0, H_S < 0 |
| 18 | 7.6531 | -1.6531 | 2.4866 | -0.0866 | 3.0000 | ✗ L_S < 0, H_S < 0 |
| 24 | 5.3092 | 0.6908 | 2.3638 | 0.0362 | 3.0000 | ✓ gültig |
| 27 | 4.5624 | 1.4376 | 2.3247 | 0.0753 | 3.0000 | ✓ gültig |
| 33 | 3.4934 | 2.5066 | 2.2686 | 0.1314 | 3.0000 | ✓ gültig |
| 39 | 2.7537 | 3.2463 | 2.2299 | 0.1701 | 3.0000 | ✓ gültig |
| 45 | 2.2009 | 3.7991 | 2.2009 | 0.1991 | 3.0000 | ✓ gültig |
| 51 | 1.7637 | 4.2363 | 2.1780 | 0.2220 | 3.0000 | ✓ gültig |


## Grenzen der Varianten

| Parameter | Wert |
|-----------|-----:|
| ΔH | 0 … 5 m |
| L₁ | 3 … 15 m |
| α_S | 3° |
| L_ES, L_AS | 1.000 m |
| H_ES, H_AS | 0.300 m |

Zelle = kleinster gültiger α_F [°], **—** = keine Lösung

### Aufwärts

| ΔH \ L₁ | 3 m | 4 m | 5 m | 6 m | 7 m | 8 m | 9 m | 10 m | 11 m | 12 m | 13 m | 14 m | 15 m |
|--------:|------:|------:|------:|------:|------:|------:|------:|------:|------:|------:|------:|------:|------:|
| 0 m | 33° | 18° | 12° | 9° | 9° | 6° | 6° | 6° | 6° | 6° | 6° | 3° | 3° |
| 1 m | — | 39° | 33° | 24° | 18° | 15° | 15° | 12° | 12° | 12° | 9° | 9° | 9° |
| 2 m | — | — | 45° | 39° | 33° | 24° | 24° | 24° | 18° | 15° | 15° | 15° | 12° |
| 3 m | — | — | 51° | 45° | 39° | 33° | 33° | 27° | 24° | 24° | 24° | 18° | 18° |
| 4 m | — | — | — | 51° | 45° | 39° | 39° | 33° | 33° | 27° | 24° | 24° | 24° |
| 5 m | — | — | — | — | 51° | 45° | 39° | 39° | 33° | 33° | 27° | 27° | 24° |

### Abwärts

| ΔH \ L₁ | 3 m | 4 m | 5 m | 6 m | 7 m | 8 m | 9 m | 10 m | 11 m | 12 m | 13 m | 14 m | 15 m |
|--------:|------:|------:|------:|------:|------:|------:|------:|------:|------:|------:|------:|------:|------:|
| 0 m | 33° | 18° | 12° | 9° | 9° | 6° | 6° | 6° | 6° | 6° | 6° | 3° | 3° |
| 1 m | 24° | 12° | 9° | 6° | 6° | 6° | 6° | — | — | — | — | — | — |
| 2 m | — | 39° | 27° | 24° | 18° | 15° | 12° | 12° | 9° | 9° | 9° | 9° | 9° |
| 3 m | — | 51° | 39° | 33° | 27° | 24° | 24° | 18° | 15° | 15° | 15° | 12° | 12° |
| 4 m | — | — | 51° | 45° | 39° | 33° | 27° | 24° | 24° | 24° | 18° | 18° | 15° |
| 5 m | — | — | — | 51° | 45° | 39° | 33° | 33° | 27° | 24° | 24° | 24° | 24° |

**Lücke bei ΔH = 1 m, L₁ ≥ 10 m:** Im Abwärts-Fall ist der Zähler der L_F-Formel
$(ΔH - H_{ES} - H_{AS}) - L_{rest} \cdot \tan(α_S)$. Bei ΔH = 1 m und L₁ = 10 m wird
$L_{rest}$ = 8 m und der Zähler = (1 − 0,3 − 0,3) − 8 · tan 3° = 0,4 − 0,419 = −0,019.
Da der Nenner für alle α_F > 3° positiv ist, wird L_F negativ — es gibt keine gültige Lösung.

Weil bei so kleinem Höhenunterschied die Reststrecke mit 3°-Neigung allein schon mehr Höhe verbraucht als verfügbar ist.
Die Reststrecke allein erzeugt durch die 3°-Neigung der S-Strecke plus H_ES + H_AS bereits mehr Höhe als der verfügbare Höhenunterschied ΔH = 1 m hergibt.