# Komplexe Widerstände und Leitwerte


```python
# Bibliotheken laden
import numpy as np
import matplotlib.pyplot as plt
import cmath # für komplexe Zahlen
# Graphikparameter
plt.style.use('classic')
plt.rcParams.update({'font.size':24})
plt.rcParams.update({'figure.autolayout': True})
```

## Impedanz vs. Admittanz

Wir betrachten hier das Wechselstromverhalten von Ohmschen Widerständen, Induktivitäten und Kapazitäten. 

Allgemein gesprochen spricht man bei Schaltkreisen mit diesen Bauelementen vom **komplexen Widerstand** bzw. von der **Impedanz** $\underline{Z}$. Der **komplexe Leitwert** heißt auch **Admittanz** $\underline{Y}$. 

Die **Impedanz** $\underline{Z}$ setzt sich zusammen aus Real- und Imaginärteil: 
- Der **Realteil** heißt **Wirkwiderstand** oder Ohmscher Widerstand oder **Resistanz** $R$. 
- Der **Imaginärteil** heißt **Blindwiderstand** oder **Reaktanz** $X$. 
- Der **Betrag** heißt **Scheinwiderstand** $Z$. 
- Und dann gibt es noch die **Phase** $\varphi_Z$.

Man kann also schreiben: 
\begin{equation}
\underline{Z} = R + jX = Z \cdot e^{j\varphi_Z}
\end{equation}

Die **Admittanz** $\underline{Y}$ setzt sich ebenfalls zusammen aus Real- und Imaginärteil: 
- Der **Realteil** heißt **Wirkleitwert** oder Ohmscher Leitwert oder **Konduktanz** $G$. 
- Der **Imaginärteil** heißt **Blindleitwert** oder **Suszeptanz** $B$. 
- Der **Betrag** heißt **Scheinleitwert** $Y=1/Z$. 
- Und dann gibt es noch die **Phase** $\varphi_Y=-\varphi_Z$.

Man kann also schreiben: 
\begin{equation}
\underline{Z} = G + jB = Y \cdot e^{j\varphi_Y}
\end{equation}

*Vorsicht! Um Impedanz und Admittanz ineinander umzurechnen, reicht es **nicht**, den Kehrwert der Wirkanteile zu nehmen. Man muss den Kehrwert der **komplexen Größe** bilden:*

\begin{equation}
\underline{Z} = \frac{1}{\underline{Y}} = \frac{1}{G+jB} = \frac{1}{Y\cdot e^{j\varphi_Y}}
\end{equation}

\begin{equation}
\underline{Y} = \frac{1}{\underline{Z}} = \frac{1}{R+jX} = \frac{1}{Z\cdot e^{j\varphi_Z}}
\end{equation}

Noch ein wichtiger **physikalischer Hinweis**: Ohmsche Widerstände oder Leitwerte können **nicht negativ** werden. Wenn Sie rechnerisch also einen negativen Wert für den Realteil einer Impedanz oder Admittanz erhalten, ist irgendwo ein Rechenfehler in Ihrer Vorgehensweise.

Einige Beispiele in python: 


```python
# komplexe Impedanz 1 Z = 6+ j2 (Ohm)
Z1 = complex(6,2)
Y1 = 1/Z1
print('Z1: ', Z1)
print('Y1: ', Y1) # 0,15 - j0,05 (Siemens)
```


```python
# komplexe Admittanz 2
Y2 = complex(0.2,-0.2) # Siemens
Z2 = 1/Y2
print('Z2: ', Z2) # Ohm
print('Y2: ', Y2)
```

**Aufgabe: Prüfen Sie die beiden Ergebnisse mit Ihrem Taschenrechner nach. Stellen Sie dazu den Taschenrechner in den komplexen Modus um.**

*Ergebnis:*


```python
# Phase der komplexen Impedanz Z1
phiZ1 = cmath.phase(Z1)
print('phiZ1: ', phiZ1, 'rad')
phiZ1g = 180*phiZ1/np.pi
print('phiZ1: ', phiZ1g, '°')
```


```python
# Phase der zugehörigen komplexen Admittanz Y1
phiY1 = cmath.phase(Y1)
print('phiY1: ', phiY1, 'rad')
phiY1g = 180*phiY1/np.pi
print('phiY1: ', phiY1g, '°')
```

**Aufgabe: Ermitteln Sie die Werte für die Admittanz $Y_2$ und deren Kehrwert $Z_2$. Benutzen Sie dafür Ihren Taschenrechner und nutzen Sie python, um Ihre Ergebnisse zu überprüfen.**

*Ergebnis:*


```python
# Scheinwiderstand der komplexen Impedanz Z1
Z1abs = np.abs(Z1)
print('Z1abs: ', Z1abs)
```

Betrag: $Z_1 = \sqrt{R_1^2 + X_1^2}$


```python
# Scheinleitwert der komplexen Admittanz Y1
Y1abs = np.abs(Y1)
print('Y1abs: ', Y1abs)
```


```python
# Überprüfung der Kehrwerte
print('Z1abs: ', Z1abs)
print('Kehrwert Y1abs: ', 1/Y1abs)
```

**Aufgabe: Berechnen Sie Scheinwiderstand und Scheinleitwert ebenso für $\underline{Y_2}$ und überprüfen Sie die Kehrwerte.**

*Ergebnis:*


```python
# Betrag und Phase in einem Befehl bei Z1
Z1absb, phiZ1b = cmath.polar(Z1)
print('Z1abs: ', Z1absb)
print('phiZ1: ', phiZ1b, ' rad')
print('phiZ1: ', 180*phiZ1b/np.pi, '°')
```


```python
# Betrag und Phase in einem Befehl bei Y1
Y1absb, phiY1b = cmath.polar(Y1)
print('Y1abs: ', Y1absb)
print('phiY1: ', phiY1b, ' rad')
print('phiY1: ', 180*phiY1b/np.pi, '°')
```

**Aufgabe: Finden Sie heraus, wie man im Taschenrechner gut zwischen Polar- und Normalform einer komplexen Zahl umrechnen kann und überprüfen Sie Ihr Ergebnis mit der Admittanz $Y_2$ in python.**

*Ergebnis:*

weitere Funktionen für komplexe Zahlen in python finden Sie in der Hilfe: https://docs.python.org/3.7/library/cmath.html

## Impedanz und Admittanz eines idealen Kondensators

**Strom eilt um $\pi/2$ vor:** 
\begin{equation}
\varphi_Z = \varphi_u - \varphi_i = -\pi/2
\end{equation}

**Impedanz des idealen Kondensators:**
\begin{equation}
\underline{Z_C} = \frac{1}{j\omega C} = \frac{1}{j 2\pi f C} = -j\cdot\frac{1}{\omega C} = j X_C
\end{equation}

**Der Wirkwiderstand eines idealen Kondensators ist $0$. Die Reaktanz $X_C$ ist gleich dem Scheinwiderstand $-Z_C = X_C$.**

**Admittanz des idealen Kondensators:**
\begin{equation}
\underline{Y_C} = j\omega C = j 2\pi f C = j \cdot B_C
\end{equation}

**Der Wirkleitwert eines idealen Kondensators ist $0$. Die Suszeptanz $B_C$ ist gleich dem Scheinleitwert  $Y_C = B_C$.**


```python
# Beispiel für einen Kondensator mit Impedanz Z3
C = 2e-6 # 6 µF
f = 3e3 # 3 kHz
Z3 = complex(0,-1/(2*np.pi*f*C))
print('Z3:', Z3, 'Ohm')
phiZ3 = cmath.phase(Z3)
print('phiZ3:', phiZ3, 'rad')
print('phiZ3g: ', 180*phiZ3/np.pi, '°')
```

**Aufgabe: Ermitteln Sie die Admittanz Y3 aus dem Bauelementwert $C$, der Frequenz $f$ und vergleichen Sie den Kehrwert mit dem obigen Ergebnis. Üben Sie zunächst mit dem Taschenrechner und nutzen Sie python zur Überprüfung.**

*Ergebnis:*

## Impedanz und Admittanz einer idealen Induktivität

**Strom eilt um $\pi/2$ nach:** 
\begin{equation}
\varphi_Z = \varphi_u - \varphi_i = \pi/2
\end{equation}

**Impedanz des idealen Kondensators:**
\begin{equation}
\underline{Z_L} = j\omega L = j2\pi f L = j X_L
\end{equation}

**Der Wirkwiderstand einer idealen Induktivität ist $0$. Die Reaktanz $X_L$ ist gleich dem Scheinwiderstand $Z_L = X_L$.**

**Admittanz der idealen Induktivität:**
\begin{equation}
\underline{Y_L} = \frac{1}{j\omega L} = \frac{1}{j 2\pi f L} = -j \frac{1}{2 \pi f L} = j\cdot B_L
\end{equation}

**Der Wirkleitwert eines idealen Kondensators ist $0$. Die Suszeptanz $B_L$ ist gleich dem Scheinleitwert multipliziert mit minus 1 $Y_L = -B_L$.**


```python
# Beispiel für eine Induktivität mit Impedanz Z4
L = 5e-6 # 5 µH
Z4 = complex(0,2*np.pi*f*L)
print('Z4:', Z4, 'Ohm')
phiZ4 = cmath.phase(Z4)
print('phiZ4:', phiZ4, 'rad')
print('phiZ4g: ', 180*phiZ4/np.pi, '°')
```

**Aufgabe: Ermitteln Sie die Admittanz Y4 aus dem Bauelementwert $L$, der Frequenz $f$ und vergleichen Sie den Kehrwert mit dem obigen Ergebnis. Üben Sie zunächst mit dem Taschenrechner und nutzen Sie python zur Überprüfung.**

*Ergebnis:*

## Serienschaltung zweier Impedanzen oder Admittanzen


```python
# Z1 und Z2 in Serie
Z12 = Z1+Z2
print('Z12:', Z12, 'Ohm')
print('Z12 polar:', cmath.polar(Z12),'Ohm')
```


```python
# Zeigerdiagramme von Z1, Z2 und Z12
# - wir machen 3 Diagramme nebeneinander
fig, ax = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(8, 4))
# linkes Diagramm 
ax[0].set_aspect('equal', adjustable='box') # Skalierung x wie y
ax[0].axis([-np.abs(Z12),np.abs(Z12),-np.abs(Z12),np.abs(Z12)])
ax[0].set_xlabel(r'$R_{1}$ [$\Omega$]',color='blue') # x-Achsentitel
ax[0].set_ylabel(r'$X$ [$\Omega$]') # y-Achsentitel
ax[0].annotate('', xytext = (0, 0),xy = (Z1.real, Z1.imag),
             arrowprops = {'facecolor' : 'blue', 
                           'edgecolor' : 'blue', 
                           'linewidth' : .001}) # Zeiger Z1
ax[0].grid() # Gitternetzlinien
# mittleres Diagramm: Z2
ax[1].set_aspect('equal', adjustable='box') # Skalierung x wie y
ax[1].set_xlabel(r'$R_{2}$ [$\Omega$]',color='green') # x-Achsentitel
ax[1].annotate('', xytext = (0, 0),xy = (Z2.real, Z2.imag),
             arrowprops = {'facecolor' : 'green', 
                           'edgecolor' : 'green', 
                           'linewidth' : .001}) # Zeiger Z2
ax[1].grid() # Gitternetzlinien
# rechtes Diagramm: Z1+Z2
ax[2].set_aspect('equal', adjustable='box') # Skalierung x wie y
ax[2].set_xlabel(r'$R_{12}$ [$\Omega$]',color='red') # x-Achsentitel
ax[2].annotate('', xytext = (0, 0),xy = (Z1.real, Z1.imag),
             arrowprops = {'facecolor' : 'blue', 
                           'edgecolor' : 'blue', 
                           'linewidth' : .001}) # Zeiger Z1
ax[2].annotate('', xytext = (Z1.real, Z1.imag),xy = (Z1.real+Z2.real, Z1.imag+Z2.imag),
             arrowprops = {'facecolor' : 'green', 
                           'edgecolor' : 'green', 
                           'linewidth' : .001}) # Zeiger Z2
ax[2].annotate('', xytext = (0, 0),xy = (Z12.real, Z12.imag),
             arrowprops = {'facecolor' : 'red', 
                           'edgecolor' : 'red', 
                           'linewidth' : .001}) # Zeiger Z12
ax[2].grid() # Gitternetzlinien
```

**Aufgabe: Ermitteln Sie ebenfalls die Impedanzen der folgenden Serienschaltungen und tragen Sie die Werte in der Tabelle (Doppelklick in Zelle -> bearbeiten *Wert* ) ein. Rechnen Sie zuerst mit dem Taschenrechner. Überprüfen Sie dann mit einem Zeigerdiagramm auf Papier und nutzen Sie python erst am Schluss, um sowohl Ihre Taschenrechner-Rechnung als auch Ihre Zeigerdiagramme zu überprüfen.**

| $Z_{1}$ in Serie mit $Z_2$ | $Z_{12}$ | *Wert* |
|----------------------------|----------|--------|
| $Z_{1}$ in Serie mit $Z_3$ | $Z_{13}$ | *Wert* |
| $Z_{1}$ in Serie mit $Z_4$ | $Z_{14}$ | *Wert* |
| $Z_{2}$ in Serie mit $Z_3$ | $Z_{23}$ | *Wert* |
| $Z_{2}$ in Serie mit $Z_4$ | $Z_{24}$ | *Wert* |
| $Z_{3}$ in Serie mit $Z_4$ | $Z_{34}$ | *Wert* |

*Kommentar:*


```python
# Admittanz
Y12 = 1/Z12
print('Y12:', Y12, 'S') # S steht für Siemens
```


```python
# Zeigerdiagramme von Y1, Y2 und Y12
# - wir machen 3 Diagramme nebeneinander
fig, ax = plt.subplots(1, 3, sharex=False, sharey=False, figsize=(8, 4))
# linkes Diagramm 
ax[0].set_aspect('equal', adjustable='box') # Skalierung x wie y
ax[0].axis([-np.abs(Y1),np.abs(Y1),-np.abs(Y1),np.abs(Y1)])
ax[0].set_xlabel(r'$G_{1}$ [S]',color='blue') # x-Achsentitel
ax[0].set_ylabel(r'$B_1$ [S]', color='blue') # y-Achsentitel
ax[0].annotate('', xytext = (0, 0),xy = (Y1.real, Y1.imag),
             arrowprops = {'facecolor' : 'blue', 
                           'edgecolor' : 'blue', 
                           'linewidth' : .001}) # Zeiger Y1
ax[0].grid() # Gitternetzlinien
# mittleres Diagramm: Y2
ax[1].set_aspect('equal', adjustable='box') # Skalierung x wie y
ax[1].axis([-np.abs(Y2),np.abs(Y2),-np.abs(Y2),np.abs(Y2)])
ax[1].set_xlabel(r'$G_{2}$ [S]',color='green') # x-Achsentitel
ax[1].set_ylabel(r'$B_2$ [S]',color='green') # y-Achsentitel
ax[1].annotate('', xytext = (0, 0),xy = (Y2.real, Y2.imag),
             arrowprops = {'facecolor' : 'green', 
                           'edgecolor' : 'green', 
                           'linewidth' : .001}) # Zeiger Y2
ax[1].grid() # Gitternetzlinien
# rechtes Diagramm: Y12
ax[2].set_aspect('equal', adjustable='box') # Skalierung x wie y
ax[2].axis([-np.abs(Y12),np.abs(Y12),-np.abs(Y12),np.abs(Y12)])
ax[2].set_xlabel(r'$G_{12}$ [S]',color='red') # x-Achsentitel
ax[2].set_ylabel(r'$B_{12}$ [S]',color='red') # y-Achsentitel
ax[2].annotate('', xytext = (0, 0),xy = (Y1.real, Y1.imag),
             arrowprops = {'facecolor' : 'blue', 
                           'edgecolor' : 'blue', 
                           'linewidth' : .001}) # Zeiger Y1
ax[2].annotate('', xytext = (Y1.real, Y1.imag),xy = (Y1.real+Y2.real, Y1.imag+Y2.imag),
             arrowprops = {'facecolor' : 'green', 
                           'edgecolor' : 'green', 
                           'linewidth' : .001}) # Zeiger Y2
ax[2].annotate('', xytext = (0, 0),xy = (Y12.real, Y12.imag),
             arrowprops = {'facecolor' : 'red', 
                           'edgecolor' : 'red', 
                           'linewidth' : .001}) # Zeiger Y12
ax[2].grid() # Gitternetzlinien
```

**Aufgabe: Warum kann man die Gesamtadmittanz $Y_{12}$ nicht durch Addieren der Einzeladmittanzen erhalten?**

*Antwort:*

**Aufgabe: Ermitteln Sie ebenfalls die Admittanzen der folgenden Serienschaltungen und tragen Sie die Werte in der Tabelle (Doppelklick in Zelle -> bearbeiten *Wert* ) ein. Rechnen Sie zuerst mit dem Taschenrechner. Nutzen Sie python dann, um Ihre Taschenrechner-Rechnung zu überprüfen.**

| $Y_{1}$ in Serie mit $Y_2$ | $Y_{12}$ | *Wert* |
|----------------------------|----------|--------|
| $Y_{1}$ in Serie mit $Y_3$ | $Y_{13}$ | *Wert* |
| $Y_{1}$ in Serie mit $Y_4$ | $Y_{14}$ | *Wert* |
| $Y_{2}$ in Serie mit $Y_3$ | $Y_{23}$ | *Wert* |
| $Y_{2}$ in Serie mit $Y_4$ | $Y_{24}$ | *Wert* |
| $Y_{3}$ in Serie mit $Y_4$ | $Y_{34}$ | *Wert* |

*Kommentar:*

## Parallelschaltung zweier Impedanzen oder Admittanzen


```python
# Z1 und Z2 parallel
Z12p = Z1*Z2/(Z1+Z2)
print('Z12p:', Z12p, 'Ohm')
print('Z12p polar:', cmath.polar(Z12p),'Ohm')
```


```python
# Zeigerdiagramme von Z1, Z2 und Z12p
# - wir machen 3 Diagramme nebeneinander
fig, ax = plt.subplots(1, 3, sharex=False, sharey=False, figsize=(8, 4))
# linkes Diagramm 
ax[0].set_aspect('equal', adjustable='box') # Skalierung x wie y
ax[0].axis([-np.abs(Z1),np.abs(Z1),-np.abs(Z1),np.abs(Z1)])
ax[0].set_xlabel(r'$R_{1}$ [$\Omega$]',color='blue') # x-Achsentitel
ax[0].set_ylabel(r'$X_1$ [$\Omega$]', color='blue') # y-Achsentitel
ax[0].annotate('', xytext = (0, 0),xy = (Z1.real, Z1.imag),
             arrowprops = {'facecolor' : 'blue', 
                           'edgecolor' : 'blue', 
                           'linewidth' : .001}) # Zeiger Z1
ax[0].grid() # Gitternetzlinien
# mittleres Diagramm: Z2
ax[1].set_aspect('equal', adjustable='box') # Skalierung x wie y
ax[1].axis([-np.abs(Z2),np.abs(Z2),-np.abs(Z2),np.abs(Z2)])
ax[1].set_xlabel(r'$R_{2}$ [$\Omega$]',color='green') # x-Achsentitel
ax[1].set_ylabel(r'$X_2$ [$\Omega$]',color='green') # y-Achsentitel
ax[1].annotate('', xytext = (0, 0),xy = (Z2.real, Z2.imag),
             arrowprops = {'facecolor' : 'green', 
                           'edgecolor' : 'green', 
                           'linewidth' : .001}) # Zeiger Z2
ax[1].grid() # Gitternetzlinien
# rechtes Diagramm: Z12p
ax[2].set_aspect('equal', adjustable='box') # Skalierung x wie y
ax[2].axis([-np.abs(Z12p),np.abs(Z12p),-np.abs(Z12p),np.abs(Z12p)])
ax[2].set_xlabel(r'$R_{12}$ [$\Omega$]',color='red') # x-Achsentitel
ax[2].set_ylabel(r'$X_{12}$ [$\Omega$]',color='red') # y-Achsentitel
ax[2].annotate('', xytext = (0, 0),xy = (Z1.real, Z1.imag),
             arrowprops = {'facecolor' : 'blue', 
                           'edgecolor' : 'blue', 
                           'linewidth' : .001}) # Zeiger Z1
ax[2].annotate('', xytext = (Z1.real, Z1.imag),xy = (Z1.real+Z2.real, Z1.imag+Z2.imag),
             arrowprops = {'facecolor' : 'green', 
                           'edgecolor' : 'green', 
                           'linewidth' : .001}) # Zeiger Z2
ax[2].annotate('', xytext = (0, 0),xy = (Z12p.real, Z12p.imag),
             arrowprops = {'facecolor' : 'red', 
                           'edgecolor' : 'red', 
                           'linewidth' : .001}) # Zeiger Z12p
ax[2].grid() # Gitternetzlinien
```

**Aufgabe: Warum kann man die Gesamtimpedanz $Z_{12,p}$ nicht durch Addieren der Einzelimpedanzen erhalten?**

*Antwort:*

**Aufgabe: Ermitteln Sie ebenfalls die Impedanzen der folgenden Parallelschaltungen und tragen Sie die Werte in der Tabelle (Doppelklick in Zelle -> bearbeiten *Wert* ) ein. Rechnen Sie zuerst mit dem Taschenrechner. Nutzen Sie python erst am Schluss, um Ihre Taschenrechner-Rechnung zu überprüfen.**

| $Z_{1}$ parallel zu $Z_2$ | $Z_{12,p}$ | *Wert* |
|----------------------------|----------|--------|
| $Z_{1}$ parallel zu $Z_3$ | $Z_{13,p}$ | *Wert* |
| $Z_{1}$ parallel zu $Z_4$ | $Z_{14,p}$ | *Wert* |
| $Z_{2}$ parallel zu $Z_3$ | $Z_{23,p}$ | *Wert* |
| $Z_{2}$ parallel zu $Z_4$ | $Z_{24,p}$ | *Wert* |
| $Z_{3}$ parallel zu $Z_4$ | $Z_{34,p}$ | *Wert* |

*Kommentar:*


```python
# Admittanz
Y12p = Y1 + Y2
print('Y12p:', Y12p, 'S') # S steht für Siemens
```


```python
# Zeigerdiagramme von Y1, Y2 und Y12p
# - wir machen 3 Diagramme nebeneinander
fig, ax = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(8, 4))
# linkes Diagramm 
ax[0].set_aspect('equal', adjustable='box') # Skalierung x wie y
ax[0].axis([-np.abs(Y12p),np.abs(Y12p),-np.abs(Y12p),np.abs(Y12p)])
ax[0].set_xlabel(r'$G_{1}$ [S]',color='blue') # x-Achsentitel
ax[0].set_ylabel(r'$B$ [S]') # y-Achsentitel
ax[0].annotate('', xytext = (0, 0),xy = (Y1.real, Y1.imag),
             arrowprops = {'facecolor' : 'blue', 
                           'edgecolor' : 'blue', 
                           'linewidth' : .001}) # Zeiger Y1
ax[0].grid() # Gitternetzlinien
# mittleres Diagramm: Y2
ax[1].set_aspect('equal', adjustable='box') # Skalierung x wie y
ax[1].set_xlabel(r'$G_{2}$ [S]',color='green') # x-Achsentitel
ax[1].annotate('', xytext = (0, 0),xy = (Y2.real, Y2.imag),
             arrowprops = {'facecolor' : 'green', 
                           'edgecolor' : 'green', 
                           'linewidth' : .001}) # Zeiger Y2
ax[1].grid() # Gitternetzlinien
# rechtes Diagramm: Y1+Y2
ax[2].set_aspect('equal', adjustable='box') # Skalierung x wie y
ax[2].set_xlabel(r'$G_{12}$ [S]',color='red') # x-Achsentitel
ax[2].annotate('', xytext = (0, 0),xy = (Y1.real, Y1.imag),
             arrowprops = {'facecolor' : 'blue', 
                           'edgecolor' : 'blue', 
                           'linewidth' : .001}) # Zeiger Y1
ax[2].annotate('', xytext = (Y1.real, Y1.imag),xy = (Y1.real+Y2.real, Y1.imag+Y2.imag),
             arrowprops = {'facecolor' : 'green', 
                           'edgecolor' : 'green', 
                           'linewidth' : .001}) # Zeiger Y2
ax[2].annotate('', xytext = (0, 0),xy = (Y12p.real, Y12p.imag),
             arrowprops = {'facecolor' : 'red', 
                           'edgecolor' : 'red', 
                           'linewidth' : .001}) # Zeiger Y12
ax[2].grid() # Gitternetzlinien
```

**Aufgabe: Ermitteln Sie ebenfalls die Admittanzen der möglichen Parallelschaltungen und tragen Sie die Werte in einer Tabelle ein. Dazu bitte: eine der oberen Zellen kopieren, einfügen und dann editieren. Rechnen Sie zuerst mit dem Taschenrechner. Überprüfen Sie dann mit einem Zeigerdiagramm auf Papier und nutzen Sie python erst am Schluss, um sowohl Ihre Taschenrechner-Rechnung als auch Ihre Zeigerdiagramme zu überprüfen.**

*Platz für Tabelle:*

*Kommentar:*

## Ohmsches Gesetz an Impedanzen oder Admittanzen


```python
# Strom
I5 = complex(1,1)
# Spannung
U5 = complex(230,0)
# Impedanz
Z5 = U5/I5
print('Z5:', Z5, 'Ohm')
# Admittanz
Y5 = I5/U5
print('Y5:', Y5, 'S')
```

**Aufgabe: Überprüfen Sie das Ergebnis mit Ihrem Taschenrechner. Verändern Sie dann die Werte der Spannung so, dass die Admittanz rein reell wird (Imaginärteil 0). Probieren Sie danach aus, die Spannung so anzupassen, dass die Impedanz rein imaginär wird (Realteil 0).**

Im Zeitbereich können wir diese beiden auch darstellen. Dafür berechnen wir die Amplitude mit $\hat{a}=A\cdot \sqrt{2}$ und die Phase $\varphi_a$ von Strom und Spannung.


```python
# Strom
i5dach = np.abs(I5)*np.sqrt(2) # Amplitude
print('i5dach =',i5dach,' A')
phii5 = cmath.phase(I5) # Phase
print('phii5 = ', phii5, ' rad')
print('phii5 = ', 180*phii5/np.pi, '°')
```


```python
# Spannung
u5dach = np.abs(U5)*np.sqrt(2) # Amplitude
print('u5dach =',u5dach,' V')
phiu5 = cmath.phase(U5) # Phase
print('phiu5 = ', phiu5, ' rad')
print('phiu5 = ', 180*phiu5/np.pi, '°')
```


```python
# Phasenverschiebung phi = phiu - phii
phi5 = phiu5 - phii5
print('phi5 = ', phi5, ' rad')
print('phi5 = ', 180*phi5/np.pi, '°')
```


```python
# Frequenz
f = 1000 # 1 kHz
omega = 2*np.pi*f
# Zeitvektor
t = np.linspace(0,3/f,1000)
# Zeitsignale
u5 = u5dach*np.cos(omega*t + phiu5)
i5 = i5dach*np.cos(omega*t + phii5)
```


```python
# Diagramm
plt.plot(1000*t,u5,label='$u_5(t)$ [V]')
plt.plot(1000*t,1000*i5,label='$i_5(t)$ [mA]')
plt.xlabel('Zeit $t$ [ms]')
plt.grid()
plt.legend()
```

**Aufgabe: Erzeugen Sie eine eigene Darstellung mit den Zahlen aus Aufgabe 2015-09-A.7 im ilias-Test (Teil-A-Tests). Geben Sie dabei hier Ihre eigenen Werte ein und stellen Sie Strom und Spannung im Diagramm dar.**


```python
# Angaben aus dem Test alle mit A7 markiert (Aufgabe 7)
# Frequenz
fA7 = 1780 # 2,02 kHz
TA7 = 1/fA7 # Periode
# Zeitvektor
tA7 = np.linspace(0,3*TA7,1000)
# Betrag der Phase, d.h. phi = phiu - phii oder phi = phii-phiu
deltatA7 = 66.32e-6 # 65,99 us
phiA7 = 2*np.pi*deltatA7/TA7 # für deltatA7 = TA7 ist 2 pi der Winkel
print('phi =',phiA7,' rad')
print('phi =',180*phiA7/np.pi, '°')
# Stromsignal ist früher -> phii = 0 (Annahme)
phiiA7 = 0
# Spannungssignal ist später -> phiu = phii + phi -> phi = phiu-phii
phiuA7 = phiiA7 + phiA7
# Amplitude auf eins setzen (nicht relevant)
uA7 = np.cos(2*np.pi*fA7*tA7 + phiuA7)
iA7 = np.cos(2*np.pi*fA7*tA7 + phiiA7)

# Diagramm
plt.plot(1000*tA7,uA7,label='$u_{A7} (t)$ [V]')
plt.plot(1000*tA7,iA7,label='$i_{A7} (t)$ [A]')
plt.grid()
plt.legend()
plt.xlabel('Zeit $t$ [ms]')
```

850c465c143f3cdd7a0f008f8972ef6dd0a67d25
ipynb
Jupyter Notebook
05GE2_komplexeimpedanzen.ipynb
johannamay/GE2
63958cc1fd0500814aa5f701f84c63f996b28baf
MIT
05GE2_komplexeimpedanzen.ipynb
johannamay/GE2
63958cc1fd0500814aa5f701f84c63f996b28baf
MIT
05GE2_komplexeimpedanzen.ipynb
johannamay/GE2
63958cc1fd0500814aa5f701f84c63f996b28baf
MIT
2020-03-14T22:27:31.000Z
2020-08-20T16:41:48.000Z
Qwen/Qwen-72B
1. YES
2. YES