lehrkraefte:blc:math-2021hw:doppelspalt [https://fginfo.ksbg.ch Fachgruppe Informatik der KSBG]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Doppelspaltexperiment ======
Siehe auch https://de.wikipedia.org/wiki/Doppelspaltexperiment


===== Mathematische Idealisierung =====
  * 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.

==== Eine Punktquelle ====
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
<hidden>
\[
  y(t) = \sin(t \cdot 2 \pi)
\]
</hidden>
  * 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)$.
<hidden>
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)$
</hidden>


=== Darstellung als Animation mit python und ffmpeg ===
  * {{lehrkraefte:blc:math-2021hw:bild.py}} Minimale Library im Bilder zu speichern (im einfachst denkbaren Format)
  * {{lehrkraefte:blc:math-2021hw: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 
<code bash>
python kreis.py
</code>
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:
<code python>
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)]
 </code>

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.
==== Mehrere Punktquellen ====
Ä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.


===== Farbcodierte Amplitude =====
==== Überlagerung zweier Schwingungen gleicher Frequenz ====
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:
<hidden>
[\ 
   \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}
\]
</hidden>

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.

<hidden>
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
<code python>
   phi = math.atan2(y,x)
</code>
</hidden>


<code python>
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
</code>

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

  * **H**: Hue in $[0,1]$ (oft auch $0^\circ$ bis $360^\circ$, <color #ff0000>$0$ entspricht Rot</color>, <color #00ff00>$\frac{1}{3}$ Grün</color>, und <color #0000ff>$\frac{2}{3}$ Blau</color>. <color #fff200>$\frac{1}{6}$ ist dann Gelb</color>, <color #00ffff>$\frac{1}{2}$ Cyan</color> und <color #ff00ff>$\frac{5}{6}$ Magenta</color>.
  * **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).