14  Interferenz: Doppelspalt und Gitter

Halte eine CD schräg ins Licht: Sie schillert in allen Regenbogenfarben — dabei ist die Scheibe selbst farblos. Kein Farbstoff, kein Filter, nur Millionen feiner Datenrillen im Abstand von anderthalb Mikrometern. Irgendetwas an dieser regelmäßigen Struktur sortiert weißes Licht nach Wellenlängen, und zwar so präzise, dass Astronomen mit demselben Prinzip die chemische Zusammensetzung von Sternen bestimmen.

Dieses Etwas ist Interferenz — die Kunst der Wellen, sich gegenseitig auszulöschen oder zu verstärken, je nachdem, ob sie im Takt oder im Gegentakt ankommen. Wir kennen den Mechanismus seit Kapitel 1 unter dem nüchternen Namen Superposition: Felder addieren sich. In diesem Kapitel lassen wir diese harmlose Addition ihr berühmtestes Schauspiel aufführen — vom Streifenmuster zweier Quellen über den Doppelspalt bis zum Gitter, das am Ende tatsächlich zwei „Farben” in zwei Richtungen sortiert. Unterwegs misst jede Behauptung nach, und ein neues Meep-Werkzeug schenkt uns den unendlich weit entfernten Schirm.

Lernziele

Nach diesem Kapitel kannst du …

  1. … das Streifenmuster zweier Quellen aus dem Gangunterschied vorhersagen (\(d\sin\theta = m\lambda\)) und erklären, wohin an den dunklen Streifen die Energie verschwindet (nirgendwohin — sie ist umverteilt),
  2. … den Doppelspalt auf zwei Huygens-Quellen zurückführen und die Einzelspalt-Hüllkurve im gemessenen Profil nachweisen,
  3. … begründen und messen, warum ein Gitter mit \(N\) Spalten \(N^2\)-fach hellere und \(1/N\)-fach schmalere Maxima wirft,
  4. … mit Meeps near2far das Fernfeld berechnen — und weißt, wann ein „Schirm” zu nah ist, um die Wahrheit zu zeigen,
  5. … erklären, wie ein Gitter Farben sortiert (\(\sin\theta_m = m\lambda/d\)), warum Rot stärker abgelenkt wird als Blau — und warum eine CD schillert.

14.1 Der Gangunterschied entscheidet

Zwei Quellen schwingen im selben Takt (dieselbe Frequenz, fester Phasenbezug — die Fachsprache nennt das kohärent; Ü 14.1 klärt, warum das im Wellenbad leicht und mit Taschenlampen aussichtslos ist). Ein Beobachter steht weit weg, in einer Richtung \(\theta\) schräg zur Mittelachse. Die Welle der ferneren Quelle muss dann ein Stück weiter laufen als die der näheren — um den Gangunterschied, und der ist reine Geometrie (dasselbe Dreieck wie beim Schritthalten in Kapitel 12):

\[\Delta = d\,\sin\theta,\]

mit \(d\) dem Quellabstand. Ist \(\Delta\) ein ganzes Vielfaches der Wellenlänge, \(\Delta = m\lambda\), kommen beide Wellen im Takt an: Berg trifft Berg, die Amplituden addieren sich — konstruktive Interferenz, ein heller Streifen der Ordnung \(m\). Liegt \(\Delta\) genau dazwischen, \(\Delta = (m + \tfrac{1}{2})\lambda\), trifft Berg auf Tal: Auslöschung, dunkel. Die Form des Übergangs liefert das Additionstheorem (das dritte Mal in diesem Buch, nach den Kapiteln 8 und 10): Zwei gleich starke Schwingungen mit Phasenversatz \(\varphi = 2\pi\Delta/\lambda\) addieren sich zu einer Schwingung der Amplitude \(2\cos(\varphi/2)\) — die Intensität (das mittlere Feldquadrat, Kapitel 4) folgt also

\[I(\theta) \;\propto\; \cos^2\!\Bigl(\frac{\pi\,d\sin\theta} {\lambda}\Bigr).\]

Die Handrechnung für unsere Bühne (\(d = 4\lambda\)): Der erste helle Streifen neben der Mitte (\(m = 1\)) liegt bei \(\sin\theta = \lambda/d = 0{,}25\), also \(\theta = 14{,}5°\); der erste dunkle bei \(\sin\theta = 0{,}125\), also \(7{,}2°\). Auf einem Schirm in Abstand \(L = 15\) (dazu gleich) erwarten wir den \(m{=}1\)-Streifen bei \(y \approx L\tan\theta = 3{,}9\).

WarnungNaheliegende Vermutung

„Licht plus Licht gibt helleres Licht. Zwei Lampen sind heller als eine — immer.”

Warum sie naheliegt: Im Alltag stimmt es ausnahmslos; zwei Glühbirnen haben noch nie einen dunklen Fleck erzeugt. Und Energieerhaltung scheint es zu verlangen: Zwei Quellen speisen doppelte Leistung ein, also muss es überall heller werden.

Was stattdessen stimmt: Felder addieren sich, nicht Helligkeiten. Wo zwei gleich starke Wellen im Gegentakt ankommen, ist es dunkel — Licht plus Licht gleich Finsternis. Die Energie fehlt dort wirklich, verletzt ist trotzdem nichts: An den hellen Streifen ist es dafür viermal so hell wie mit einer Quelle (Amplitude verdoppelt, Intensität vervierfacht), und über den Schirm gemittelt bleibt exakt das Doppelte übrig. Interferenz ist ein Umverteiler, kein Schöpfer. Alle drei Zahlen — 4, 0 und 2 — messen wir gleich nach. (Der Alltag sieht davon nichts, weil Glühbirnen nicht kohärent sind; Ü 14.1.)

14.2 Zwei Quellen auf der Messbank

Der Versuchsaufbau: Bühne — eine \(24 \times 24\)-Zelle (\(\lambda_0 = 1\), also \(f_\text{meep} = 1\); Auflösung 16 Punkte pro \(\lambda\)), ringsum PML. Quellen: zwei gleichphasige Ez-Punktquellen (Dauerstrich) bei \(x = -6\), \(y = \pm 2\) — Abstand \(d = 4\lambda\). Gemessen wird auf einem „Schirm”: einer senkrechten Linie bei \(x = +9\) (\(L = 15\) hinter den Quellen), knapp vor der PML. Als Messgröße dient die Intensität, das Zeitmittel von \(E_z^2\) — praktisch: einschwingen lassen, dann \(E_z\) über eine volle Periode in 16 Schnappschüssen mitteln. Erwartung als einzeichenbare Theorielinie: nicht nur die cos²-Form, sondern die ehrliche Version mit allem, was wir wissen — die Amplitude jeder 2D-Quelle fällt wie \(1/\sqrt{r}\) (Kapitel 9), also

\[I(y) \;\propto\; \frac{1/2}{r_1} + \frac{1/2}{r_2} + \frac{\cos\bigl(2\pi(r_2 - r_1)/\lambda\bigr)}{\sqrt{r_1 r_2}},\]

worin \(r_{1,2}\) die exakten Abstände des Schirmpunkts zu beiden Quellen sind (die ersten beiden Terme sind die Einzelhelligkeiten, der dritte ist der Interferenzterm — er pendelt mit dem Gangunterschied \(r_2 - r_1\) zwischen Verstärken und Löschen). Erfolgskriterium: Messprofil auf der Theorielinie (rms unter 5 %), und die 4/0/2-Zahlen aus der Refutation.

import os
os.environ["HWLOC_HIDE_ERRORS"] = "2"   # wie in Kap. 11–13

import numpy as np
import matplotlib.pyplot as plt
import meep as mp

mp.verbosity(0)

AUFL = 16
SX, SY = 24.0, 24.0
F = 1.0                 # λ0 = 1
X_Q, X_S = -6.0, 9.0    # Quellen- und Schirmposition
L = X_S - X_Q
SCHIRM = 22.0           # Länge der Schirmlinie
D2 = 4.0                # Quellabstand


def punktquellen(ys, amplituden=None):
    """Gleichgetaktete Ez-Punktquellen bei x = X_Q, Höhen ys."""
    return [mp.Source(mp.ContinuousSource(F, width=2), component=mp.Ez,
                      center=mp.Vector3(X_Q, y),
                      amplitude=1.0 if amplituden is None else amplituden[i])
            for i, y in enumerate(ys)]


def schirm_intensitaet(quellen, geometrie=(), vollbild=False):
    """Einschwingen, dann Ez² über eine Periode mitteln."""
    sim = mp.Simulation(cell_size=mp.Vector3(SX, SY), resolution=AUFL,
                        boundary_layers=[mp.PML(1.0)], sources=quellen,
                        geometry=list(geometrie))
    sim.run(until=45.0)
    acc = []
    def sammle(s):
        if vollbild:
            acc.append(s.get_array(component=mp.Ez, center=mp.Vector3(),
                                   size=mp.Vector3(SX, SY)))
        else:
            acc.append(s.get_array(component=mp.Ez, center=mp.Vector3(X_S, 0),
                                   size=mp.Vector3(0, SCHIRM)))
    sim.run(mp.at_every(1.0 / F / 16, sammle), until=1.0 / F)
    I = np.mean(np.square(acc), axis=0)
    if vollbild:
        return I
    return np.linspace(-SCHIRM / 2, SCHIRM / 2, len(I)), I


karte_zwei = schirm_intensitaet(punktquellen((-D2 / 2, D2 / 2)),
                                vollbild=True)
y, I_zwei = schirm_intensitaet(punktquellen((-D2 / 2, D2 / 2)))
print(f"eingeschwungen; Schirmprofil mit {len(y)} Punkten")
Using MPI version 4.1, 1 processes
eingeschwungen; Schirmprofil mit 354 Punkten
WichtigVorhersage-Punkt

Bevor das Bild erscheint: Ist es auf der Mittellinie (\(y = 0\), gleich weit von beiden Quellen) hell oder dunkel? Und auf wie viele helle Streifen insgesamt tippst du auf dem Schirm von \(y = -9\) bis \(+9\)? (Die Handrechnung oben kennt die Antwort.)

Gleicher Weg heißt Gangunterschied null heißt: im Takt — die Mitte ist hell. Und da der Schirmrand bei \(y = 9\) unter \(\theta = 31°\) erscheint (\(\sin\theta = 0{,}51\), also bis \(m = \pm 2\)): fünf Streifen. Das Bild dazu:

# von oben: karte_zwei, y, I_zwei, L, D2, SX, SY, X_S
r1 = np.hypot(L, y - D2 / 2)            # exakte Wege zu beiden Quellen
r2 = np.hypot(L, y + D2 / 2)
drei_term = (0.5 / r1 + 0.5 / r2
             + np.cos(2 * np.pi * F * (r2 - r1)) / np.sqrt(r1 * r2))

fig, achsen = plt.subplots(1, 2, figsize=(7.4, 3.4),
                           gridspec_kw={"width_ratios": [1.15, 1]})
ax = achsen[0]
ax.imshow(np.sqrt(karte_zwei).T, origin="lower", cmap="inferno",
          extent=(-SX / 2, SX / 2, -SY / 2, SY / 2))
ax.axvline(X_S, color="white", ls="--", lw=0.9)
ax.set_xlabel("x (λ)"); ax.set_ylabel("y (λ)")
ax.set_title("zwei Quellen, d = 4λ", fontsize=10)

ax = achsen[1]
fenster = np.abs(y) < 9
ax.plot(y, I_zwei / I_zwei[fenster].max(), "o", ms=2.6, label="Messung")
ax.plot(y, drei_term / drei_term[fenster].max(), "k-", lw=1.0,
        label="Theorie (3 Terme)")
ax.set_xlim(-9, 9); ax.set_ylim(0, 1.05)
ax.set_xlabel("y am Schirm (λ)"); ax.set_ylabel("I (normiert)")
ax.set_title("Schirmprofil", fontsize=10)
ax.legend(fontsize=8)
plt.tight_layout(); plt.show()
Abbildung 14.1: Links: die Intensität (Zeitmittel von Ez², Wurzel-Farbskala) zweier gleichphasiger Quellen — aus dem Überlappgebiet wachsen helle Strahlen, getrennt von dunklen Auslöschungs-Schneisen; die gestrichelte Linie ist der Schirm. Rechts: das Profil auf dem Schirm (Punkte) liegt auf der Drei-Term-Theorielinie mit den exakten Abständen r₁, r₂ und den 1/√r-Amplituden aus Kapitel 9 (rms-Abweichung 3 %): fünf helle Streifen, die Mitte am hellsten, die Minima praktisch schwarz.

Fünf Streifen, Mitte hell, Messpunkte auf der Linie. Jetzt die drei Zahlen aus der Refutation — dafür braucht es noch den Referenzlauf mit einer Quelle:

# von oben: punktquellen(), schirm_intensitaet(), I_zwei, y, fenster
_, I_eine = schirm_intensitaet(punktquellen((0.0,)))
mitte = len(y) // 2
print(f"hellster Streifen : {I_zwei[mitte] / I_eine[mitte]:.2f}-mal"
      f" eine Quelle   (Theorie: 4)")
print(f"dunkelster Punkt  : {I_zwei.min() / I_zwei.max():.1e}"
      f" vom Maximum    (Theorie: 0)")
print(f"Schirm-Mittelwert : {I_zwei[fenster].mean() / I_eine[fenster].mean():.2f}-mal"
      f" eine Quelle   (Theorie: 2)")
hellster Streifen : 3.98-mal eine Quelle   (Theorie: 4)
dunkelster Punkt  : 3.9e-04 vom Maximum    (Theorie: 0)
Schirm-Mittelwert : 2.04-mal eine Quelle   (Theorie: 2)

Viermal, (praktisch) null, zweimal — die Energie der zweiten Quelle ist vollständig da, nur eben von den dunklen in die hellen Streifen geschoben. Wer übrigens grübelt, wie die Quellen das „wissen”: gar nicht. Jede sendet stur ihre Ringwelle; das Muster entsteht erst in der Addition am Messort.

Genau diesen Punkt — laufende Wellen, stehendes Muster — zeigt in dieser HTML-Fassung der Film: das rohe \(E_z\) über eine volle Periode. Die Wellenberge rasen nach außen (Einzelschritt-Knöpfe!), aber die dunklen Schneisen bleiben unbeweglich an ihrem Ort: Auslöschung ist kein Augenblick, sondern ein Ort — dort kommen die beiden Ringwellen in jedem einzelnen Bild gegenphasig an.

Code der Animation (nur in der HTML-Fassung)
# von oben: punktquellen(), SX, SY, AUFL, D2, F, X_S
from matplotlib import animation
from IPython.display import HTML

sim_film = mp.Simulation(cell_size=mp.Vector3(SX, SY), resolution=AUFL,
                         boundary_layers=[mp.PML(1.0)],
                         sources=punktquellen((-D2 / 2, D2 / 2)))
sim_film.run(until=45.0)                 # einschwingen wie bei der Messung
filmbilder = []
sim_film.run(mp.at_every(1.0 / F / 16, lambda s: filmbilder.append(
    s.get_array(component=mp.Ez, center=mp.Vector3(),
                size=mp.Vector3(SX, SY)))), until=1.0 / F)
filmbilder = filmbilder[:16]             # eine Periode: nahtloser Loop

fig_a, ax_a = plt.subplots(figsize=(5.4, 5.0))
w_a = np.abs(filmbilder[0]).max() / 3
bild_a = ax_a.imshow(filmbilder[0].T, origin="lower", cmap="RdBu_r",
                     vmin=-w_a, vmax=w_a,
                     extent=(-SX / 2, SX / 2, -SY / 2, SY / 2))
ax_a.axvline(X_S, color="black", ls="--", lw=0.9)
ax_a.plot([X_Q, X_Q], [-D2 / 2, D2 / 2], "ko", ms=4)
ax_a.set_xlabel("x (λ)"); ax_a.set_ylabel("y (λ)")
ax_a.set_title("Wellen laufen, das Muster steht")

def zeichne(j):
    bild_a.set_data(filmbilder[j].T)
    return [bild_a]

anim = animation.FuncAnimation(fig_a, zeichne, frames=len(filmbilder),
                               interval=110)
plt.close(fig_a)
HTML(anim.to_jshtml(default_mode="loop"))

14.3 Der Doppelspalt: zwei Quellen aus einer Wand

Historisch lief das Experiment andersherum — Thomas Young hatte 1801 keine zwei kohärenten Quellen, sondern eine Welle und eine Wand mit zwei Schlitzen. Dass das auf dasselbe hinausläuft, ist die Huygens-Idee aus der Kapitel-9-Übung: Jeder Spalt, klein gegen die Wellenlänge, wirkt als eigene Punktquelle — und beide werden von derselben ankommenden Welle angestoßen, sind also automatisch kohärent. Der Aufbau: dieselbe Bühne, aber statt der zwei Quellen eine ebene Welle (eine breite Linienquelle am linken Rand) und bei \(x = -6\) eine PEC-Wand mit zwei Spalten der Breite \(w = 0{,}8\lambda\) im Abstand \(d = 4\lambda\) — gebaut mit einem Stanz-Trick: erst die durchgehende Metallwand, dann zwei Luftblöcke darüber (spätere Objekte überschreiben frühere). Gemessen wird wie eben; Erwartung: dasselbe Streifenmuster wie bei zwei Quellen. Ob das ganz aufgeht, zeigt der Vergleich:

# von oben: schirm_intensitaet(), y, fenster, drei_term, X_Q, D2, SY
W_SPALT, DICKE = 0.8, 0.4
# mp.metal: idealer Leiter (das PEC aus Kap. 6), mp.air: Luft/Vakuum
wand = [mp.Block(size=mp.Vector3(DICKE, mp.inf, mp.inf),
                 center=mp.Vector3(X_Q, 0), material=mp.metal),
        mp.Block(size=mp.Vector3(DICKE, W_SPALT, mp.inf),    # „ausstanzen":
                 center=mp.Vector3(X_Q, +D2 / 2), material=mp.air),
        mp.Block(size=mp.Vector3(DICKE, W_SPALT, mp.inf),    # Luft ersetzt
                 center=mp.Vector3(X_Q, -D2 / 2), material=mp.air)]  # Metall
ebene_welle = [mp.Source(mp.ContinuousSource(F, width=2), component=mp.Ez,
                         center=mp.Vector3(-10.5, 0),
                         size=mp.Vector3(0, SY - 2))]

_, I_spalt = schirm_intensitaet(ebene_welle, wand)
karte_spalt = schirm_intensitaet(ebene_welle, wand, vollbild=True)

d_naiv = np.abs(I_spalt / I_spalt[fenster].max()
                - drei_term / drei_term[fenster].max())[fenster]
print(f"Doppelspalt vs. Zweiquellen-Theorie:"
      f" max. Abweichung {d_naiv.max() * 100:.0f} %")
Doppelspalt vs. Zweiquellen-Theorie: max. Abweichung 42 %

Autsch — die Streifen sind da, aber bis zu 42 % daneben? Bevor jemand Meep verdächtigt: Querrechnen heißt der Differenz zuhören (Kapitel 11). Ein Blick auf das Profil verrät, wo sie wohnt — die äußeren Streifen sind zu schwach, und zwar systematisch mit dem Winkel. Das ist kein Fehler, sondern die Physik des einzelnen Spalts: \(w = 0{,}8\lambda\) ist eben nicht klein gegen \(\lambda\). Ein Spalt endlicher Breite ist selbst eine kleine Kette von Huygens-Quellen, deren Beiträge unter schrägen Winkeln gegeneinander laufen — er strahlt nach vorn am stärksten und zu den Seiten schwächer. Das Fernfeld dieser Kette ist die Einzelspalt-Hüllkurve

\[I_\text{Spalt}(\theta) \;\propto\; \Bigl(\frac{\sin x}{x}\Bigr)^{\!2}, \qquad x = \frac{\pi w \sin\theta}{\lambda},\]

mit der ersten Nullstelle bei \(w\sin\theta = \lambda\) (die Mini-Kette löscht sich aus, wenn über die Spaltbreite genau eine Wellenlänge Gangunterschied liegt — bei uns erst bei \(\sin\theta = 1{,}25\), also nie ganz: die Hülle drückt nur, sie löscht nicht). Das Doppelspalt-Muster ist das Produkt aus beidem: Zweiquellen-Streifen mal Hüllkurve.

# von oben: karte_spalt, I_spalt, y, fenster, drei_term, W_SPALT, L
sin_theta = y / np.hypot(L, y)
# np.sinc(x) = sin(πx)/(πx) — NumPy steckt das π selbst hinein
huelle = np.sinc(W_SPALT * sin_theta / 1.0) ** 2
theorie_spalt = drei_term * huelle

fig, achsen = plt.subplots(1, 2, figsize=(7.4, 3.4),
                           gridspec_kw={"width_ratios": [1.15, 1]})
ax = achsen[0]
ax.imshow(np.sqrt(karte_spalt).T, origin="lower", cmap="inferno",
          extent=(-SX / 2, SX / 2, -SY / 2, SY / 2))
ax.axvline(X_S, color="white", ls="--", lw=0.9)
ax.set_xlabel("x (λ)"); ax.set_ylabel("y (λ)")
ax.set_title("Doppelspalt (w = 0,8λ)", fontsize=10)

ax = achsen[1]
ax.plot(y, I_spalt / I_spalt[fenster].max(), "o", ms=2.6, label="Messung")
ax.plot(y, theorie_spalt / theorie_spalt[fenster].max(), "k-", lw=1.0,
        label="Zweiquellen × Hülle")
ax.plot(y, huelle / huelle.max(), ":", color="gray", lw=1.0,
        label="Hüllkurve")
ax.set_xlim(-9, 9); ax.set_ylim(0, 1.05)
ax.set_xlabel("y am Schirm (λ)"); ax.set_ylabel("I (normiert)")
ax.set_title("Profil mit Hüllkurve", fontsize=10)
ax.legend(fontsize=8)
plt.tight_layout(); plt.show()

d_mit = np.abs(I_spalt / I_spalt[fenster].max()
               - theorie_spalt / theorie_spalt[fenster].max())[fenster]
print(f"mit Hüllkurve: max {d_mit.max() * 100:.0f} %,"
      f" rms {np.sqrt((d_mit**2).mean()) * 100:.0f} %")
Abbildung 14.2: Links: der Doppelspalt im Intensitätsbild — die ebene Welle von links wird von der Wand (bei x = −6) bis auf zwei Spalte blockiert, dahinter fächern dieselben Strahlen auf wie bei zwei Punktquellen. Rechts: das Schirmprofil (Punkte) gegen die Zweiquellen-Theorie mal Einzelspalt-Hüllkurve (Linie; die Hüllkurve selbst gepunktet): Die Streifen LIEGEN exakt wie bei zwei Quellen, ihre Helligkeit folgt der Hülle — Abweichung nur noch 2 % rms statt 42 % ohne Hülle.
mit Hüllkurve: max 6 %, rms 2 %

Die 42 % sind auf 2 % rms zusammengefallen — die Hüllkurve war keine Ausrede, sondern messbare Notwendigkeit. Merkenswert ist die Arbeitsteilung: Der Abstand \(d\) der Spalte bestimmt, wo die Streifen liegen; die Breite \(w\) jedes Spalts bestimmt, wie weit hinaus sie hell bleiben.

14.4 Vom Doppelspalt zum Gitter

Was passiert mit mehr Spalten — sagen wir \(N\) gleichphasigen Quellen im Abstand \(d\)? Die hellen Streifen können nur dort bleiben, wo alle \(N\) Beiträge im Takt sind, und das sind exakt die alten Orte \(d\sin\theta = m\lambda\) (wenn Nachbarn im Takt sind, sind es alle). Aber zwei Dinge ändern sich drastisch, und beide folgen aus einem Bild: Stelle die \(N\) Beiträge als \(N\) Uhrzeiger dar, deren Richtung die Ankunftsphase zeigt. Im Hauptmaximum zeigen alle in dieselbe Richtung — Gesamtamplitude \(N\), Intensität \(N^2\). Verlässt man das Maximum nur ein wenig, verdrehen sich die Zeiger gegeneinander; vollständig dunkel wird es, sobald sie gleichmäßig über den ganzen Kreis verteilt sind und sich zu null schließen — und das passiert schon, wenn zwischen Nachbarn der Gangunterschied \(\lambda/N\) liegt (der ganze Zeigerfächer spannt dann genau eine Umdrehung auf). Das Hauptmaximum endet also bei \(\sin\theta = \lambda/(N d)\) statt bei \(\lambda/(2d)\): \(N\)-mal schmaler. Mehr Spalte machen die Streifen nicht zahlreicher, sondern schärfer und heller — aus dem sanften cos² wird ein Kamm aus Nadeln.

Nur: Womit messen? Hier wartet eine Falle, in die wir beim Schreiben dieses Kapitels prompt selbst getappt sind. Acht Quellen im Abstand \(2\lambda\) sind ein \(14\lambda\) breites Instrument, und ein scharfer Beugungskamm bildet sich erst dort aus, wo alle \(N\) Teilwellen als ebene Front ankommen — die Faustformel verlangt Schirmabstände groß gegen \((\text{Breite})^2/\lambda \approx 200\). Unser Schirm bei \(L = 15\) steht also mitten im Nahfeld-Gewühl; sein Profil zeigt dort schlicht nicht die Gitterformel (wer mag, probiere es — das Hauptmaximum verbreitert sich scheinbar mit \(N\), weil die äußeren Quellen schon geometrisch weiter weg sind). Was wir bräuchten, ist ein unendlich ferner Schirm. Den hat Meep im Regal: add_near2far zeichnet die Felder auf einer Linie hinter den Quellen auf (frequenzaufgelöst — es ist derselbe DFT-Monitor aus Kapitel 11 in neuer Rolle) und rechnet daraus nach dem Lauf das Feld an beliebig fernen Punkten aus. Genau dieses Werkzeug vermisst in Teil VI die Strahlungsdiagramme von Antennen; hier ist seine Premiere. Der Aufbau der Gitterserie: \(N = 2, 4, 8\) Punktquellen (\(d = 2\lambda\)), als Puls angeregt (für saubere DFT-Fernfelder, wie bei den Flux-Messungen seit Kapitel 12), Aufzeichnungslinie bei \(x = -2\), ausgewertet auf einem Bogen im Abstand 1000. Erfolgskriterium: zentrale Höhe \(\propto N^2\) (Faktor 4 je Verdopplung), Halbwertsbreite \(\propto 1/N\) (Faktor 2).

# von oben: X_Q, SX, SY, AUFL
D_GITTER = 2.0
R_FERN = 1000.0


def fernfeld(n_quellen, f_mitte, f_breite, n_freq):
    """Fernfeld-Winkelprofile |Ez|² einer Reihe von Puls-Punktquellen."""
    ys = (np.arange(n_quellen) - (n_quellen - 1) / 2) * D_GITTER
    quellen = [mp.Source(mp.GaussianSource(1.1, fwidth=0.5), component=mp.Ez,
                         center=mp.Vector3(X_Q, yq)) for yq in ys]
    sim = mp.Simulation(cell_size=mp.Vector3(SX, SY), resolution=AUFL,
                        boundary_layers=[mp.PML(1.0)], sources=quellen)
    # add_near2far: zeichnet die Felder auf der Linie auf (DFT) und kann
    # daraus später das Feld an beliebig fernen Punkten ausrechnen;
    # Frequenzraster wie bei add_flux: n_freq Punkte um f_mitte ± f_breite/2
    nahfeld = sim.add_near2far(f_mitte, f_breite, n_freq,
                               mp.Near2FarRegion(center=mp.Vector3(-2.0, 0),
                                                 size=mp.Vector3(0, SY - 2)))
    sim.run(until_after_sources=60)
    winkel = np.linspace(-60, 60, 481)
    profile = np.zeros((n_freq, len(winkel)))
    for i, th in enumerate(np.radians(winkel)):
        punkt = mp.Vector3(X_Q + R_FERN * np.cos(th), R_FERN * np.sin(th))
        ff = sim.get_farfield(nahfeld, punkt)   # 6 Feldkomponenten je
        for k in range(n_freq):                 # Frequenz, Ez ist Nr. 2
            profile[k, i] = abs(ff[6 * k + 2]) ** 2
    return winkel, profile


gitter = {}
for n in (2, 4, 8):
    w, p = fernfeld(n, 1.0, 0, 1)
    gitter[n] = p[0]

fig, ax = plt.subplots(figsize=(6.8, 3.4))
for n, farbe in ((2, "tab:gray"), (4, "tab:orange"), (8, "tab:blue")):
    ax.plot(w, gitter[n] / gitter[8].max(), color=farbe, lw=1.2,
            label=f"N = {n}")
ax.set_xlim(-45, 45)
ax.set_xlabel("Winkel (°)"); ax.set_ylabel("I (auf N = 8 normiert)")
ax.legend(fontsize=9)
plt.tight_layout(); plt.show()
Abbildung 14.3: Das Fernfeld (near2far, Abstand 1000) der Quellreihen mit N = 2, 4 und 8 (d = 2λ), alle auf das N = 8-Maximum normiert: Die Hauptmaxima bleiben bei 0° und ±30° (d·sinθ = mλ) liegen, aber sie wachsen mit jeder Verdopplung um den Faktor vier und werden halb so breit — aus den sanften Zweiquellen-Hügeln (grau) wird der Nadelkamm des Gitters (blau). Zwischen den Nadeln liegen die schwachen Nebenmaxima der Zeiger-Zwischenstellungen.

Die Messzahlen zur Vorhersage:

# von oben: gitter, w
def halbwertsbreite(w, p):
    j = np.argmin(np.abs(w))
    halb = p[j] / 2
    rechts = j + np.argmax(p[j:] < halb)
    links = j - np.argmax(p[:j + 1][::-1] < halb)
    return w[rechts] - w[links]


h = {n: gitter[n][np.argmin(np.abs(w))] for n in (2, 4, 8)}
b = {n: halbwertsbreite(w, gitter[n]) for n in (2, 4, 8)}
print(f"zentrale Höhe   : N=2→4: ×{h[4]/h[2]:.2f},  N=4→8: ×{h[8]/h[4]:.2f}"
      f"   (Theorie: ×4)")
print(f"Halbwertsbreite : {b[2]:.1f}° / {b[4]:.1f}° / {b[8]:.1f}°"
      f"  → Verhältnisse {b[2]/b[4]:.2f} und {b[4]/b[8]:.2f}  (Theorie: ≈2)")
zentrale Höhe   : N=2→4: ×4.08,  N=4→8: ×4.22   (Theorie: ×4)
Halbwertsbreite : 17.0° / 7.5° / 3.5°  → Verhältnisse 2.27 und 2.14  (Theorie: ≈2)

\(N^2\) und \(1/N\), beide getroffen. Diese Schärfung ist der ganze Daseinszweck des Gitters: Eine Nadel, deren Position von \(\lambda\) abhängt und deren Breite mit jedem weiteren Spalt schrumpft, ist ein Messgerät für Wellenlängen — bei einem echten Gitter mit zehntausenden Rillen werden aus unseren Nadeln Skalpelle, die Spektrallinien auf sechs Stellen trennen.

14.5 Das Gitter als Spektrometer

Zeit für den Höhepunkt: zwei „Farben” gleichzeitig. Die Position der ersten Ordnung hängt über \(\sin\theta_1 = \lambda/d\) von der Wellenlänge ab — verschiedene Farben landen auf verschiedenen Winkeln, das Gitter ist ein Spektrometer.

WichtigVorhersage-Punkt

Wir schicken zwei Frequenzen durch das \(N{=}8\)-Gitter: \(f = 1\) („rot”, \(\lambda = 1\)) und \(f = 1{,}25\) („blau”, \(\lambda = 0{,}8\)). Welche Farbe wird stärker abgelenkt? Wer beim Glasprisma aufgepasst hat, tippe trotzdem nicht vorschnell — und rechne mit \(\sin\theta_1 = \lambda/d\) kurz nach.

Beim Prisma gewinnt Blau (dazu mehr in Kapitel 16) — beim Gitter ist es umgekehrt: Die größere Wellenlänge braucht den größeren Winkel für denselben Gangunterschied, Rot wird stärker abgelenkt (\(\sin\theta = 1/2 \to 30{,}0°\) gegen \(0{,}8/2 \to 23{,}6°\)). Und die Messung kostet dank Kapitel 10 nur einen Lauf: Der Anregungspuls enthält beide Frequenzen sowieso (schmal in der Zeit, breit im Spektrum), und der near2far-Monitor sortiert sie — wir bestellen einfach beide Frequenzen auf seinem Raster:

# von oben: fernfeld(), D_GITTER
# Frequenzraster f_mitte ± f_breite/2 → genau (1,0 und 1,25)
w, p2 = fernfeld(8, 1.125, 0.25, 2)

fig, ax = plt.subplots(figsize=(6.8, 3.2))
for k, (f, farbe, name) in enumerate(((1.0, "tab:red", "f = 1 („rot“)"),
                                      (1.25, "tab:blue", "f = 1,25 („blau“)"))):
    ax.plot(w, p2[k] / p2[k].max(), color=farbe, lw=1.3, label=name)
    ax.axvline(np.degrees(np.arcsin((1 / f) / D_GITTER)), color=farbe,
               ls=":", lw=1.0)
    maske = (w > 10) & (w < 50)
    print(f"f = {f}: 1. Ordnung gemessen bei"
          f" {w[maske][np.argmax(p2[k][maske])]:.2f}°"
          f"  (arcsin(λ/d) = {np.degrees(np.arcsin((1/f)/D_GITTER)):.2f}°)")
ax.set_xlim(0, 50)
ax.set_xlabel("Winkel (°)"); ax.set_ylabel("I (je Farbe normiert)")
ax.legend(fontsize=9)
plt.tight_layout(); plt.show()
f = 1.0: 1. Ordnung gemessen bei 30.00°  (arcsin(λ/d) = 30.00°)
f = 1.25: 1. Ordnung gemessen bei 23.50°  (arcsin(λ/d) = 23.58°)
Abbildung 14.4: Ein einziger Pulslauf durch das N = 8-Gitter, zwei DFT-Fernfelder: Die erste Beugungsordnung von „Rot“ (f = 1, λ = 1) liegt bei 30,0°, die von „Blau“ (f = 1,25, λ = 0,8) bei 23,5° — jeweils auf der gepunkteten Theorielinie arcsin(λ/d). Das Gitter sortiert Farben, und zwar andersherum als ein Prisma: Die längere Wellenlänge wird stärker abgelenkt. (Profile je Farbe normiert; der gemeinsame Gipfel am linken Rand ist die nullte Ordnung, in der alle Farben zusammenfallen.)

Zwei Farben, zwei Nadeln, beide auf der Theorielinie — das CD-Rätsel vom Kapitelanfang ist damit Mechanik: Die Datenrillen sind ein Reflexionsgitter mit \(d = 1{,}6\) µm, jede Lichtwellenlänge bekommt ihre eigene Richtung, und beim Kippen der Scheibe wandert ein anderer Teil des sortierten Regenbogens ins Auge (Ü 14.2 rechnet die Winkel aus). Astronomen treiben es nur präziser: Gitterspektrografen zerlegen Sternenlicht so fein, dass chemische Fingerabdrücke und Dopplerverschiebungen ablesbar werden — alles Anwendungen von \(d\sin\theta = m\lambda\).

14.6 Das Kapitel-Programm

programme/kap14/kap14_interferenz_gitter.py bündelt alle Befunde eigenständig, mit assert-Schranken: Zweiquellen-Profil auf der Drei-Term-Theorie (rms < 5 %), die 4/0/2-Zahlen, Doppelspalt ohne Hülle > 20 % daneben und mit Hülle < 10 % (rms < 4 %), Gitterhöhen ∝ \(N^2\) und Breiten ∝ \(1/N\) in ±15-%-Fenstern, Spektrometer-Winkel auf 1°, dazu die Übungs-Befunde (gegenphasig, \(d < \lambda\)).

TippMerkkasten
  • Felder addieren sich, nicht Helligkeiten: hell ist, wo der Gangunterschied \(d\sin\theta\) ein Vielfaches von \(\lambda\) ist — dort viermal so hell wie eine Quelle; dazwischen dunkel; im Mittel zweimal. Interferenz verteilt um, sie erschafft nichts.
  • Spalte sind Quellen (Huygens): Der Spalt-Abstand setzt die Streifen-Orte, die Spalt-Breite die Hüllkurve (\(\sin x/x\)², erste Null bei \(w\sin\theta = \lambda\)).
  • Gitter = Schärfemaschine: \(N\) Spalte machen die Maxima \(N^2\)-fach hell und \(N\)-fach schmal (Zeigerbild: dunkel, sobald die \(N\) Zeiger den Kreis schließen). Orte bleiben \(d\sin\theta = m\lambda\).
  • Gitter sortieren Farben — Rot stärker als Blau (umgekehrt zum Prisma). Eine CD ist ein Gitter mit \(d = 1{,}6\) µm.
  • Schirme können zu nah sein: Beugungsmuster gelten im Fernfeld (\(L \gg \text{Breite}^2/\lambda\)); Meeps near2far liefert den unendlich fernen Schirm aus einem Nahfeld-Lauf.

Roter Faden

Die Superposition aus Kapitel 1 hat hier ihren großen Auftritt gehabt, choreografiert von der Gangunterschieds-Geometrie aus Kapitel 12 und vermessen mit dem Intensitätsbegriff aus Kapitel 4; die \(1/\sqrt{r}\)-Amplituden (Kapitel 9) steckten in der Theorielinie, die Huygens-Übung von dort wurde zum Doppelspalt befördert, und „schmal in der Zeit, breit im Spektrum” (Kapitel 10) lieferte beide Spektrometer-Farben in einem Puls. Nach vorn: Kapitel 16 stellt das Gitter dem Prisma gegenüber (Dispersion — dort klärt sich, warum das Prisma andersherum sortiert), Kapitel 21/23 übernehmen near2far und bauen aus unserer Quellenreihe ein Antennen-Array — dass ein Phased Array und ein Beugungsgitter dasselbe Rechenwerk sind, ist dann keine Überraschung mehr —, und Kapitel 26 lässt Gitter aus ganzen Kristallebenen interferieren (photonische Bandlücken).

Übungen

Ü 14.1 (Verstehen). Zwei Taschenlampen nebeneinander werfen keine Interferenzstreifen an die Wand — zwei Lautsprecher mit demselben Sinussignal erzeugen aber sehr wohl hörbare „taube Stellen” im Raum. Erkläre den Unterschied mit dem Begriff der Kohärenz. (Denkhilfe: Was müsste zwischen den Feldern beider Quellen über die ganze Messdauer konstant bleiben, damit sich ein ortsfestes Muster ausbildet — und was macht das Licht einer Glühwendel alle paar Nanosekunden?)

Ein ortsfestes Streifenmuster braucht einen festen Phasenbezug: Der Gangunterschied entscheidet nur dann dauerhaft über hell und dunkel, wenn die beiden Quellen ihren Takt zueinander nie wechseln. Unsere Meep-Quellen (und die zwei Lautsprecher am selben Generator) sind perfekt kohärent — ein Muster, für immer. Eine Glühwendel dagegen sendet das Gemeinschaftswerk unzähliger unabhängiger Atome, deren Phasenlage sich nach jedem Emissionsakt — alle paar Nanosekunden — zufällig neu würfelt; zwei getrennte Lampen würfeln zudem unabhängig. Das Streifenmuster existiert in jedem Nanosekunden-Augenblick durchaus, springt aber milliardenfach pro Sekunde an neue Orte; Auge und Kamera sehen nur den Mittelwert, und der ist strukturlos „zweimal so hell” (das Schirm-Mittel aus der Refutation!). Young löste das Problem 1801 genial sparsam: eine Quelle, per Doppelspalt in zwei Kopien geteilt — Kopien desselben Würfelwurfs sind zueinander immer kohärent.

Ü 14.2 (Verstehen). Die Datenrillen einer CD liegen \(1{,}6\) µm auseinander. Berechne von Hand (und prüfe mit drei Zeilen Code) die Winkel der ersten Beugungsordnung für blaues (450 nm), grünes (532 nm) und rotes (650 nm) Licht — bei senkrechtem Lichteinfall. Welche Farbe liegt außen im CD-Regenbogen? Und warum zeigt eine DVD (\(d = 0{,}74\) µm) ihre Farben unter steileren Winkeln?

\(\sin\theta_1 = \lambda/d\): blau \(0{,}281 \to 16{,}3°\), grün \(0{,}333 \to 19{,}4°\), rot \(0{,}406 \to 24{,}0°\) — Rot außen, wie bei unserem Zwei-Farben-Experiment. Die DVD packt ihre Spuren mehr als doppelt so eng; kleineres \(d\) heißt größeres \(\lambda/d\), also wandern alle Ordnungen nach außen (rot: \(\sin\theta = 0{,}88 \to 61{,}5°\)), und die zweite Ordnung passt gar nicht mehr hinein.

# von oben: nichts (eigenständige Handrechnungs-Kontrolle)
for d_um in (1.6, 0.74):
    winkel = [np.degrees(np.arcsin(lam / (d_um * 1000)))
              for lam in (450, 532, 650)]
    print(f"d = {d_um} µm:  blau {winkel[0]:.1f}°,"
          f" grün {winkel[1]:.1f}°, rot {winkel[2]:.1f}°")
d = 1.6 µm:  blau 16.3°, grün 19.4°, rot 24.0°
d = 0.74 µm:  blau 37.5°, grün 46.0°, rot 61.4°

Ü 14.3 (Verändern). Drehe eine der beiden Quellen aus dem ersten Experiment um — amplituden=(1.0, -1.0) lässt sie im Gegentakt schwingen. Sage vorher: Was wird aus dem hellen Streifen in der Mitte, und wohin rücken die Maxima? Miss nach.

Der eingebaute Gegentakt wirkt wie ein zusätzlicher halber Wellenlängen-Gangunterschied: Überall, wo es hell war, wird es dunkel und umgekehrt — die Mitte (Gangunterschied null, Gegentakt bleibt Gegentakt) wird zum dunklen Streifen, die Maxima rücken auf die alten Minima bei \(d\sin\theta = (m + \tfrac{1}{2})\lambda\):

# von oben: punktquellen(), schirm_intensitaet(), I_zwei, y, mitte
_, I_gegen = schirm_intensitaet(punktquellen((-D2 / 2, D2 / 2),
                                             amplituden=(1.0, -1.0)))
print(f"Mitte: {I_gegen[mitte] / I_zwei[mitte]:.1e} der gleichphasigen")
print(f"hellster Streifen jetzt bei y = {y[np.argmax(I_gegen)]:.1f}"
      f"   (dort lag vorher das erste Minimum, y ≈ ±1,9)")
Mitte: 6.0e-04 der gleichphasigen
hellster Streifen jetzt bei y = -2.0   (dort lag vorher das erste Minimum, y ≈ ±1,9)

Das Muster ist exakt invertiert — die Phase der Quellen ist ein ebenso scharfes Steuer wie ihre Position. Genau dieser Hebel (Phasen statt Orte verschieben!) lenkt in Kapitel 23 die Keule eines Phased-Array-Radars, ganz ohne bewegliche Teile.

Ü 14.4 (Übertragen). Rücke die beiden Quellen auf \(d = 0{,}8\lambda\) zusammen — enger als eine Wellenlänge. Sage mit \(d\sin\theta = m\lambda\) voraus, wie viele helle Streifen der Schirm noch zeigt, und miss nach. Warum ist dieses unscheinbare Ergebnis für Antennenbauer eine Designregel?

Für \(m = 1\) müsste \(\sin\theta = \lambda/d = 1{,}25\) sein — das gibt es nicht. Es bleibt allein die nullte Ordnung: ein breiter Hügel, nirgends mehr vollständige Auslöschung (der Gangunterschied erreicht \(\lambda/2\) erst jenseits des Schirmrands):

# von oben: punktquellen(), schirm_intensitaet(), y, fenster, I_zwei, SCHIRM
def maxima_zaehlen(I):
    """Lokale Maxima über 30 % des Größten (Mindestabstand 1 λ)."""
    schritt = int(len(I) / SCHIRM)
    gefunden = []
    for i in range(schritt, len(I) - schritt):
        if abs(y[i]) < 9 and I[i] > 0.3 * I[fenster].max() \
                and I[i] == I[i - schritt:i + schritt + 1].max() \
                and (not gefunden or i - gefunden[-1] >= schritt):
            gefunden.append(i)
    return len(gefunden)


_, I_eng = schirm_intensitaet(punktquellen((-0.4, 0.4)))
print(f"helle Streifen: d = 0,8λ → {maxima_zaehlen(I_eng)},"
      f"   d = 4λ → {maxima_zaehlen(I_zwei)}")
helle Streifen: d = 0,8λ → 1,   d = 4λ → 5

Für Antennen-Arrays (Kapitel 23) ist das die halbe Miete: Dort will man genau eine Hauptkeule und keine Kopien davon in andere Richtungen (sie hießen dort „Grating Lobes” — wörtlich: Gitterkeulen). Die Designregel lautet deshalb: Elementabstand unter einer Wellenlänge halten — dieselbe Mathematik, die hier die Streifen abschaltet, schaltet dort die Geisterkeulen ab.

Das Kleingedruckte

Unsere „Farben” \(f = 1\) und \(f = 1{,}25\) liegen eine Viertel Oktave auseinander; echtes Weißlicht füllt das Intervall kontinuierlich, und jede Ordnung wird zum durchgehenden Spektralband (deshalb überlappen sich bei Gittern die hohen Ordnungen: das Rot der zweiten erreicht das Blau der dritten). Die Fraunhofer-Bedingung \(L \gg B^2/\lambda\) verdient ihren eigenen Respekt: Für ein 10-cm-Gitter im sichtbaren Licht liegt der „ferne” Schirm jenseits von zwanzig Kilometern — reale Spektrometer falten den Weg deshalb mit einer Sammellinse, die das Fernfeld in ihre Brennebene holt (optisch exakt das, was near2far numerisch tut). Und wer den Doppelspalt mit einzelnen Photonen betreibt, betritt das vielleicht tiefste Experiment der Physik — Kapitel 30 wagt den Blick.