Doppelspaltexperiment

Siehe auch https://de.wikipedia.org/wiki/Doppelspaltexperiment

Wir betrachten nur Punktquellen an der Stelle der Spalten.
Wir betrachten nur den 2-dimensionalen Fall
Erst mal ignorieren wir die Abnahme der Amplitude mit der Enfernung.

Siehe auch Fundamentum Seite 88/89

Position $P_0=(p_x, p_y)$
Fixe Frequenz $f=1$
Fixe Nullphase $\varphi_0 = 0$.
Wellenlänge $\lambda=10$ (in Pixel)
Amplitude 1

Auslenkung zur Zeit $t$ and Stelle $(x,y)$

Siehe auch Fundamentum Seite 88/89

Ziel ist es die Auslenkung $y(x,y,t)$ am Punkt $(x,y)$ zur Zeit $t$ zu bestimmen.

Bestimmen Sie erst mal die Funktion $y(p_x, p_y, t)$, d.h. die Auslenkung an der Punktquelle

Click to display ⇲

Click to hide ⇱

\[ y(t) = \sin(t \cdot 2 \pi) \]

Für einen beliebigen Punkt $P=(x,y)$ gehen Sie wie folgt vor:
- Bestimmen Sie die Distanz zu $P_0$.
- Aus der Wellenlänge, berechnen Sie die Zeit, die die Welle benötigt, um von $P_0$ zu $P$ zu gelangen.
- Bestimmen Sie damit $y(x,y,t)$.

Click to display ⇲

Click to hide ⇱

Distanz: $d = \sqrt{(x-p_x)^2+(y-p_y)^2}$

Zeit: Pro Umdrehung eine Wellenlänge $\lambda$, also $\Delta t = \frac{d}{\lambda}$

$y(x,y,t)$ hat eine «Verspätung» von $\Delta t$, also $y(x,y,t) = \sin(t\cdot 2\pi - \Delta t)$

Darstellung als Animation mit python und ffmpeg

bild.py Minimale Library im Bilder zu speichern (im einfachst denkbaren Format)
kreis.py Vorlage mit pulsierendem Kreis

Laden Sie beide Dateien in ein neues Verzeichnis.

Öffnen Sie dieses Verzeichnis mit Visual Studio Code.

Starten Sie die Datei 'kreis.py', was einen Haufen Bilder erzeugen wird.

Oder auf der Kommandozeile, starten Sie

python kreis.py

und erstellen Sie dann mit ffmpeg (siehe Output) die Animation, die Sie mit einem Browser anschauen können.

Punktwelle darstellen

Öffnen Sie das Verzeichnis Visual Studio Code und fügen der Datei kreis.py nach der Initialisierung der Variablen bild (ca. Zeile 10) folgende Funktionen hinzu:

wlang = 10  # Wellenlänge in Pixeln (lambda ist ein reserviertes keyword in python)
def auslenkung(px, py, x, y, t):
  # Auslenkung a im Punkt (x,y) zur Zeit t berechnen
  a = 1   # TODO Berechnung einfügen
  return a
 
def farbe(x,y,t):
  # Punktequelle in der Mitte
  a = auslenkung(w/2, h/2, x, y, t)
  # TODO a in den Bereich [0,1] umrechnen
 
  # Graustufe  (Alternative: hsv_to_rbg(h,s,v) verwenden)
  return [int(a*255), int(a*255), int(a*255)]

Vervollständigen Sie die Funktionen und ändern Sie unten im Hauptprogramm den Funktionsaufruf von kreisFarbe zu farbe um.

Für grössere Animationen können Sie eine .mp4 anstatt einer .gif Datei generieren. Passen Sie die Kommandozeil mit ffmpeg entsprechend an.

Ändern Sie die Funktion farbe wie folgt: Platzieren Sie zwei Punktquellen unten am Bildrand, addieren Sie die Auslenkungen und passen Sie die Umrechnung auf das Intervall [0,1] entsprechend an.

Gegeben sind zwei Schwingungen gleicher Frequenz mit Amplituden $a_1$ und $a_2$ und Nullphasen $\varphi_1$ und $\varphi_2$.

Ziel ist es, die Amplitude und Nullphase der Summe beider Schwingungen zu berechnen.

Drehende Vektoren (Zeiger)

Für dieses Problem ist sehr nützlich, Schwingungen als Projektion einer Kreisbewegung zu betrachten, genauer als die $y$-Koordinate eines drehenden Vektors (Zeigers) um den Ursprung. Die Länge des Vektors entspricht der Amplitude, die Nullphase ist der orientierte Winkel, die der Vektor zur Zeit $t=0$ einschliesst.

Weil die zu überlagernden Schwingungen die gleiche Frequenz haben, bleibt der Winkel zwischen beiden Vektoren (Zeigern) konstant. Es reicht darum, die Situation zum Zeitpunkt $t=0$ zu betrachten. Das hat ausserdem den Vorteil, dass die Nullphase $\varphi$ der Überlagung so gleich ersichtlich ist.

Seien $\vec{v_1}$ und $\vec{v_2}$ die Vektoren der beiden Schwingungen zum Zeitpunkt $t=0$. Dann ist der entsprechende Vektor der Überlagerung $\vec{v} = \vec{v_1}+\vec{v_2}$. Von diesem Vektor entspricht die Länge $a$ der Amplitude der Überlagerung, und der orientierte Winkel von $\vec{v}$ gegenüber der $x$-Achse entspricht der gesuchten Nullphase $\varphi$.

Die Komponenten der Vektoren $\vec{v_1}$ und $\vec{v_2}$ können wie folgt aufgeschrieben werden:

Click to display ⇲

Click to hide ⇱

[\

 \vec{v_1} = \begin{pmatrix} a_1 \cdot \sin(\varphi_1) \\ a_1 \cdot \cos(\varphi_1) \end{pmatrix}
 \qquad
 \vec{v_2} = \begin{pmatrix} a_2 \cdot \sin(\varphi_2) \\ a_1 \cdot \cos(\varphi_2) \end{pmatrix}

\]

Daraus folgt die Summe $\vec{v} = \vec{v_1}+\vec{v_2}$ und $a=\vec{v}$.

Berechnung der Nullphase, «Winkel von $\vec{v}$»

Wir suchen einen Winkel in $[0, 2\pi]$ (oder in $[-\pi, \pi]$). Aber auf jeden Fall auf dem ganzen Vollkreis. Alle Arcus-Funktionen liefern aber nur Winkel auf einem Intervall der Länge $\pi$ ($180^\circ$).

Es ist sind also Fallunterscheidungen nötig.

Click to display ⇲

Click to hide ⇱

Da die Bestimmung des orientierten Winkel eines Vektors gegenüber der $x$-Achse ein häufiges Problem ist, gibt es in den meisten Programmiersprachen (und auch direkt in Hardware) die Funktion \[ \text{atan2}(y,x) \mapsto [-\pi, \pi[ \] In Python

   phi = math.atan2(y,x)

def ueberlagerung(phi1, phi2, a1=1, a2=1):
  v1x = math.cos(phi1)*a1
  v1y = math.sin(phi1)*a1
  v2x = math.cos(phi2)*a2
  v2y = math.sin(phi2)*a2
  vx = v1x+v2x
  vy = v1y+v2y
  a = math.sqrt(vx*vx+vy*vy)   # Amplitude
  phi = math.atan(vy, vx)  # Nullphase
  return a,phi

HSV-Farbmodell

https://de.wikipedia.org/wiki/HSV-Farbraum

H: Hue in $[0,1]$ (oft auch $0^\circ$ bis $360^\circ$, $0$ entspricht Rot, $\frac{1}{3}$ Grün, und $\frac{2}{3}$ Blau. $\frac{1}{6}$ ist dann Gelb, $\frac{1}{2}$ Cyan und $\frac{5}{6}$ Magenta.
S: Saturation in $[0,1]$, $0$ wäre Grau, $1$ Voll gesättigte Farbe
V: Value in $[0,1]$: Helligkeit ($0$ ist Schwarz, $1$ volle Helligkeit).