27  Ringresonator und Fabry-Pérot

Am Ende von Kapitel 26 stand eine Kuriosität: Eine einzige λ/2-Schicht zwischen zwei fast perfekten Spiegeln ließ bei genau einer Frequenz alles Licht hindurch — \(T = 1{,}000\) durch eine Wand, die sonst 99,9 % zurückwirft. Was dort als Nadel in der Bandlücke auftauchte, ist eines der ältesten und nützlichsten Bauteile der Optik: das Fabry-Pérot- Interferometer, zwei Spiegel im Abstand \(L\). Es steckt im Etalon des Spektroskopikers, in jeder Laserdiode — und in den vier Kilometer langen Armen von LIGO, wo es Licht hunderte Male hin- und herfaltet, bis eine Längenänderung von einem Zehntausendstel Protonendurchmesser messbar wird.

In diesem Kapitel verstehen wir den Resonator erst als Echo-Summe (eine geometrische Reihe, die wir seit der Lampen-Treppe in Kapitel 22 im Griff haben), messen dann seinen Frequenz-Kamm in Meep nach — und biegen ihn anschließend zum Kreis: Der Ringresonator ist ein Fabry-Pérot ohne Spiegel und das Arbeitspferd der Silizium-Photonik. Zum Schluss tun wir, was seit Kapitel 19 in der Luft liegt: Wir füllen den Resonator mit Verstärkung und sehen einen Laser an seiner Schwelle anspringen.

Lernziele

Nach diesem Kapitel kannst du …

  1. … die Transmission eines Fabry-Pérot als geometrische Reihe der Umlauf-Echos herleiten und weißt, warum auf Resonanz \(T = 1\) wird, obwohl jeder Spiegel fast alles reflektiert,
  2. … den Frequenz-Kamm vermessen: freier Spektralbereich \(\mathrm{FSR} \approx 1/(2L)\), Finesse \(\pi\sqrt{R}/(1-R)\), Güte \(Q\) — und du kennst die Feldüberhöhung in der Kavität,
  3. … erklären, wie ein Ringresonator an einen Wellenleiter koppelt (evaneszent, Kapitel 17), warum im Bus Dips entstehen und was die azimutale Modenzahl ist,
  4. … kritische Kopplung erkennen: Der Transmissions-Dip wird genau dann perfekt schwarz, wenn Koppel- und Eigenverlust gleichziehen — die Impedanzanpassung der Photonik,
  5. … die Laser-Schwelle quantitativ vorhersagen: Verstärkungsrate = Verlustrate des kalten Resonators — und du weißt, warum erst die Sättigung aus einem Verstärker einen stabilen Oszillator macht (Kapitel 19).

27.1 Die Echo-Summe: vom Klingeln zum Kamm

Was macht ein Puls zwischen zwei Teilspiegeln? Er klingelt. Genau das haben wir in Übung 6.4 gemessen: Zwischen zwei Glasgrenzen hin- und herlaufende Echos, jedes um den Reflexionsfaktor leiser. Und in Kapitel 22 hat uns die Lampen-Treppe gezeigt, wie man mit so etwas rechnet: Die Echos bilden eine geometrische Reihe, und geometrische Reihen kann man aufsummieren.

Nehmen wir zwei identische Teilspiegel (Amplituden \(r\) fürs Reflektieren, \(t\) fürs Durchlassen) im Abstand \(L\). Eine Welle, die ganz hindurch will, hat unendlich viele Wege: direkt durch beide Spiegel; oder drinnen einmal extra hin und zurück; oder zweimal; oder … Jeder zusätzliche Umlauf multipliziert die Amplitude mit demselben Faktor — zweimal reflektieren, zweimal die Strecke \(L\):

\[ t_{\text{ges}} = t^2\,\mathrm{e}^{-\mathrm{i}\varphi} \sum_{m=0}^{\infty} \left(r^2 \mathrm{e}^{-2\mathrm{i}\varphi}\right)^m = \frac{t^2\,\mathrm{e}^{-\mathrm{i}\varphi}} {1 - r^2\,\mathrm{e}^{-2\mathrm{i}\varphi}}, \qquad \varphi = \frac{2\pi f}{c}\,L . \]

Ein Wort zur Phasenuhr, bevor wir rechnen — hier lauert dieselbe Falle wie zwischen Meep und NEC in Kapitel 23 (unsere Regel von dort: Konventionen prüft man an einem Fall mit bekannter Antwort). Unsere Transfer-Matrix aus Kapitel 26 hat eine eingebaute Vorzeichenwahl, und der Testfall ist eine schlichte Leerstrecke: Ihre Matrix liefert \(t = \mathrm{e}^{-\mathrm{i}\delta}\) — die Laufphase zählt in dieser Konvention negativ. Also muss auch der Umweg in unserer Reihe als \(\mathrm{e}^{-\mathrm{i}\varphi}\) auftreten, sonst landen die Resonanzen an den falschen Stellen.

Als Spiegel nehmen wir das einfachste, was das Regal hergibt: je eine λ/4-Schicht mit \(n = 3\) (bei der Bezugsfrequenz \(f_0 = 0{,}25\)), Kavität \(L = 5\) Luft dazwischen. Eine solche Einzelschicht reflektiert

\[ R = \left(\frac{1 - n^2}{1 + n^2}\right)^2 = \left(\frac{-8}{10}\right)^2 = 0{,}64 . \]

Vorhersage-Punkt (PRIMM): Beide Spiegel werfen 64 % der Leistung zurück. Wie viel kommt auf Resonanz — wenn alle Echos im Takt sind — durch das Paar? Höchstens \(0{,}36^2 \approx 13\,\%\)? Mehr? Rechne nicht, rate — und sieh dann zu, wie die Reihe konvergiert.

import numpy as np
import matplotlib.pyplot as plt

# --- Transfer-Matrix-Werkzeug (wie Kap. 26) ---
F0, N_SP = 0.25, 3.0
D_SP = 1.0 / (4 * N_SP * F0)     # lambda/4-Spiegelschicht
L = 5.0                          # Kavitaetslaenge (Luft)


def schichtmatrix(n, d, f):
    """Charakteristische 2x2-Matrix einer Schicht (Kap. 26)."""
    delta = 2.0 * np.pi * f * n * d
    return np.array([[np.cos(delta), 1j * np.sin(delta) / n],
                     [1j * n * np.sin(delta), np.cos(delta)]])


def rt_von(M):
    """komplexe r und t einer Kette zwischen Luft-Halbraeumen."""
    nenner = (M[0, 0] + M[0, 1]) + (M[1, 0] + M[1, 1])
    r = ((M[0, 0] + M[0, 1]) - (M[1, 0] + M[1, 1])) / nenner
    t = 2.0 / nenner
    return r, t


# Phasenuhr-Probe: Leerstrecke der Dicke d hat t = e^(-i*delta)
_, t_vak = rt_von(schichtmatrix(1.0, 1.0, 0.25))
print(f"Leerstrecke: t = {t_vak:.4f}  (e^(-i pi/2) = {np.exp(-1j*np.pi/2):.4f})")

r_sp, t_sp = rt_von(schichtmatrix(N_SP, D_SP, F0))
print(f"Einzelspiegel: R = {np.abs(r_sp)**2:.4f}")

# Echo-Summe gegen die exakte Transfer-Matrix des Gesamtsystems
def fp_t_tmm(f):
    M = schichtmatrix(N_SP, D_SP, f) @ schichtmatrix(1.0, L, f) \
        @ schichtmatrix(N_SP, D_SP, f)
    return rt_von(M)[1]


F_RES = 0.2946                    # eine Resonanz (gleich gemessen)
r, t = rt_von(schichtmatrix(N_SP, D_SP, F_RES))
phi = 2 * np.pi * F_RES * L
print("\nEcho-Summe auf Resonanz:")
for n_um in [1, 2, 5, 10, 30]:
    s = sum((r**2 * np.exp(-2j * phi))**m for m in range(n_um))
    print(f"  {n_um:3d} Umläufe: T = {np.abs(t**2 * np.exp(-1j*phi) * s)**2:.4f}")
t_exakt = t**2 * np.exp(-1j * phi) / (1 - r**2 * np.exp(-2j * phi))
print(f"  geschlossene Reihe: T = {np.abs(t_exakt)**2:.6f}")
print(f"  Transfer-Matrix:    T = {np.abs(fp_t_tmm(F_RES))**2:.6f}")
print(f"  Differenz: {abs(np.abs(t_exakt)**2 - np.abs(fp_t_tmm(F_RES))**2):.1e}")
Leerstrecke: t = 0.0000-1.0000j  (e^(-i pi/2) = 0.0000-1.0000j)
Einzelspiegel: R = 0.6400

Echo-Summe auf Resonanz:
    1 Umläufe: T = 0.1433
    2 Umläufe: T = 0.3767
    5 Umläufe: T = 0.8232
   10 Umläufe: T = 0.9829
   30 Umläufe: T = 1.0000
  geschlossene Reihe: T = 0.999968
  Transfer-Matrix:    T = 0.999968
  Differenz: 1.6e-15

Hundert Prozent — durch zwei 64-%-Spiegel. Das erste Echo allein bringt nur 13 %, aber die Nachzügler stapeln sich phasenrichtig obendrauf, und die geschlossene Reihe stimmt mit der Transfer-Matrix auf Maschinengenauigkeit überein (sie ist dieselbe Physik, nur anders sortiert). Der Mechanismus ist derselbe wie bei der λ/2-Nadel aus Übung 26.3: Auf Resonanz baut sich in der Kavität so viel Feld auf, dass dessen Leck durch den Eingangsspiegel die direkte Reflexion exakt auslöscht — destruktive Interferenz rückwärts heißt konstruktive vorwärts. Ein Resonator ist ein Anti-Spiegel für seine Lieblingsfrequenz.

Aus der Reihe folgt mit \(R = |r|^2\) sofort die berühmte Airy-Formel (Nenner ausmultiplizieren):

\[ T(f) = \frac{(1-R)^2}{1 + R^2 - 2R\cos\delta}, \qquad \delta = \frac{4\pi f L}{c} - 2\arg(r), \]

und mit ihr der ganze Kamm: Maxima (\(T = 1\)), wann immer die Umlaufphase \(\delta\) ein Vielfaches von \(2\pi\) trifft.

# von oben: schichtmatrix(), rt_von(), fp_t_tmm(), N_SP, D_SP, L
fs = np.linspace(0.15, 0.35, 2001)
T_tmm = np.array([np.abs(fp_t_tmm(f))**2 for f in fs])


def airy_T(f):
    r, _ = rt_von(schichtmatrix(N_SP, D_SP, f))
    R = np.abs(r)**2
    delta = 4 * np.pi * f * L - 2 * np.angle(r)
    return (1 - R)**2 / (1 + R**2 - 2 * R * np.cos(delta))


T_airy = np.array([airy_T(f) for f in fs])
print(f"max |Airy - TMM| = {np.max(np.abs(T_airy - T_tmm)):.1e}")

# Kamm vermessen: Resonanzlagen, FSR, Halbwertsbreite -> Finesse
from scipy.signal import argrelmax   # lokale Maxima eines Arrays
i_res = [i for i in argrelmax(T_tmm)[0] if T_tmm[i] > 0.9]
f_res = fs[i_res]
fsr = float(np.diff(f_res).mean())
ip = i_res[-1]
ueber = T_tmm > 0.5
lo = hi = ip
while ueber[lo - 1]:
    lo -= 1
while ueber[hi + 1]:
    hi += 1
fwhm = fs[hi] - fs[lo]
R_SP = np.abs(rt_von(schichtmatrix(N_SP, D_SP, F0))[0])**2
print(f"Resonanzen: {np.round(f_res, 4)}")
print(f"FSR = {fsr:.4f}   (1/(2L) = {1/(2*L):.4f}  ->  L_eff = {1/(2*fsr):.2f})")
print(f"Finesse = FSR/FWHM = {fsr/fwhm:.2f}   "
      f"(ideal pi*sqrt(R)/(1-R) = {np.pi*np.sqrt(R_SP)/(1-R_SP):.2f})")

fig, ax = plt.subplots(figsize=(7.0, 4.0))
ax.plot(fs, T_tmm, "C1-", lw=1.5, label="Transfer-Matrix")
ax.plot(fs[::25], T_airy[::25], "C0o", ms=4, mfc="none", label="Airy-Formel")
for k in range(-1, 3):
    ax.axvline(0.25 + k * 0.1, color="0.55", ls="--", lw=0.9)
ax.axvline(0.25, color="0.55", ls="--", lw=0.9,
           label="naive Kammteilung 1/(2L)")
ax.set_xlabel("Frequenz  $f\\,a/c$")
ax.set_ylabel("Transmission $T$")
ax.set_title("Zwei Spiegel, ein Kamm")
ax.legend(fontsize=9)
ax.grid(alpha=0.3)
plt.show()
max |Airy - TMM| = 3.0e-15
Resonanzen: [0.2054 0.2946]
FSR = 0.0892   (1/(2L) = 0.1000  ->  L_eff = 5.61)
Finesse = FSR/FWHM = 6.56   (ideal pi*sqrt(R)/(1-R) = 6.98)
Abbildung 27.1: Der Fabry-Pérot-Kamm aus der Transfer-Matrix (Linie) mit der Airy-Formel (Punkte — deckungsgleich): Resonanzen mit T = 1 im Abstand des freien Spektralbereichs, dazwischen sperrt das Spiegelpaar besser als ein Einzelspiegel (T unter 0,1). Gestrichelt die naive Kammteilung 1/(2L): Der echte Kamm ist enger — die Welle wohnt ein Stück weit im Spiegel.

Zwei Messwerte verdienen einen zweiten Blick:

  • Der freie Spektralbereich (FSR), der Abstand der Kammzähne, ist die Umlauf-Frequenz des Resonators: \(\mathrm{FSR} = c/(2L)\) — ein Echo pro Umlauf, eine Resonanz pro aufgesammelter Vollphase. Gemessen: 0,0892 statt 0,1. Kein Fehler, sondern Kapitel 12/26: Die Welle dringt beim Reflektieren ein Stück in den Spiegel ein (ihre Reflexionsphase \(\arg r\) dreht sich mit \(f\)), der Resonator ist optisch länger als gebaut — \(L_{\text{eff}} = 5{,}61\) statt 5.
  • Die Finesse \(\mathcal{F} = \mathrm{FSR}/\mathrm{FWHM}\) zählt, wie viele Linienbreiten zwischen zwei Zähne passen — die Trennschärfe des Kamms. Ideal wäre \(\pi\sqrt{R}/(1-R) = 6{,}98\); unsere realen (dispersiven) Spiegel liefern 6,6.

27.2 Der Kamm im Experiment

Jetzt Meep — derselbe 1D-Aufbau wie beim Bragg-Stapel in Kapitel 26. Frage: Liegt der gemessene Kamm auf der Theorielinie, inklusive der \(T = 1\)-Spitzen? Bühne: 1D-Zelle (dimensions=1), zwei \(n = 3\)-Schichten der Dicke \(1/3\) im Abstand 5, beidseits Luft und PML. Anfangsbedingungen: breiter Gauß-Puls vor dem ersten Spiegel. Messgrößen: Fluss hinter dem zweiten Spiegel, normiert auf den Leerlauf. Erfolgskriterium: rms-Abstand zur Transfer-Matrix im Prozentbereich.

# von oben: N_SP, D_SP, L, fp_t_tmm()
import meep as mp

mp.verbosity(0)

DPML, LUFT = 2.0, 3.0
LZ = 2 * DPML + 2 * LUFT + 2 * D_SP + L
AUFL = 40


def spiegel_geom():
    zi = -(L / 2 + D_SP / 2)
    return [mp.Block(size=mp.Vector3(mp.inf, mp.inf, D_SP),
                     center=mp.Vector3(0, 0, s * zi),
                     material=mp.Medium(index=N_SP)) for s in (-1, 1)]


def sweep_1d(geom):
    sim = mp.Simulation(
        cell_size=mp.Vector3(0, 0, LZ), dimensions=1, resolution=AUFL,
        boundary_layers=[mp.PML(DPML)], geometry=geom,
        sources=[mp.Source(mp.GaussianSource(0.25, fwidth=0.25),
                           component=mp.Ex,
                           center=mp.Vector3(0, 0, -LZ / 2 + DPML + 0.5))])
    z_m = LZ / 2 - DPML - 0.5
    tr = sim.add_flux(0.25, 0.25, 801,
                      mp.FluxRegion(center=mp.Vector3(0, 0, z_m)))
    sim.run(until_after_sources=mp.stop_when_fields_decayed(
        50, mp.Ex, mp.Vector3(0, 0, z_m), 1e-9))
    return np.array(mp.get_flux_freqs(tr)), np.array(mp.get_fluxes(tr))


fs_m, P_ref = sweep_1d([])
_, P_fp = sweep_1d(spiegel_geom())
T_meep = P_fp / P_ref
T_theo = np.array([np.abs(fp_t_tmm(f))**2 for f in fs_m])
fen = (fs_m > 0.15) & (fs_m < 0.35)
print(f"rms(Meep - TMM) = {np.sqrt(np.mean((T_meep[fen]-T_theo[fen])**2)):.4f}")
Using MPI version 4.1, 1 processes
rms(Meep - TMM) = 0.0014
# von oben: fs_m, T_meep, T_theo, fen, fs, T_tmm
fig, ax = plt.subplots(figsize=(7.0, 4.0))
ax.plot(fs, T_tmm, "C1-", lw=1.5, label="Transfer-Matrix")
ax.plot(fs_m[fen][::10], T_meep[fen][::10], "C0o", ms=4.5, mfc="none",
        label="Meep 1D (jeder 10. Punkt)")
ax.set_xlabel("Frequenz  $f\\,a/c$")
ax.set_ylabel("Transmission $T$")
ax.set_title("Der Kamm besteht die Nagelprobe")
ax.legend(fontsize=9)
ax.grid(alpha=0.3)
plt.show()
Abbildung 27.2: Meep-Messpunkte auf der Transfer-Matrix-Linie: Der Kamm stimmt über den ganzen Sweep, die Spitzen erreichen T = 1,000 — durch zwei 64-%-Spiegel. Dieselbe Doppelprobe wie in Kapitel 26, jetzt für den Resonator.

27.2.1 Güte und Klingeldauer

Der Kamm verrät über seine Linienbreite die Güte \(Q = f/\Delta f \approx 22\) — und Kapitel 15 verlangt die Gegenprobe über das Abklingen: Ein Resonator mit Güte \(Q\) klingelt \(Q/2\pi\) Schwingungen lang, sein Feld fällt wie \(\mathrm{e}^{-\omega t/2Q}\). Der Versuchsaufbau: Frage: Liefert das Ausklingen dasselbe \(Q\) wie die Linienbreite? Bühne: dieselbe Zelle; ein kurzer Puls stößt die Mode bei \(f = 0{,}2946\) in der Kavität an, danach lauschen wir an einer Sonde. Messgröße: die Amplitude der Resonanzschwingung über der Zeit — gemessen mit einem gleitenden Lock-in: In Fenstern von vier Perioden multiplizieren wir das Signal mit \(\mathrm{e}^{-2\pi\mathrm{i} f_{\text{res}} t}\) und mitteln — der Frequenz-Detektor aus Kapitel 10, nur eben Fenster für Fenster. Das hört ausschließlich auf die Mode und ignoriert alles andere; warum uns das gleich noch den Hals rettet, zeigt der Laser-Abschnitt. Erfolgskriterium: \(\ln\)-Amplitude auf einer Geraden, \(Q\) aus der Steigung gleich dem Kamm-\(Q\).

Nebenbefund fürs Werkstattbuch: Das bequeme mp.Harminv aus Kapitel 15 ist hier nutzlos — es verwirft Moden mit \(Q < 50\) grundsätzlich als numerischen Müll. Für unser \(Q \approx 22\) heißt es selber fitten.

# von oben: spiegel_geom(), LZ, DPML, AUFL, L
F_RES = 0.2946


def lockin_rate(sig=0.0, dauer=250):
    """Klingelrate der Resonanzmode (Feld), per gleitendem Lock-in.

    sig > 0 fuellt die Kavitaet mit Verstaerkung (kommt im
    Laser-Abschnitt) — die Messroutine bleibt dieselbe.
    """
    geom = spiegel_geom()
    if sig > 0:
        geom = geom + [mp.Block(size=mp.Vector3(mp.inf, mp.inf, L),
                                center=mp.Vector3(0, 0, 0),
                                material=mp.Medium(D_conductivity=-sig))]
    sim = mp.Simulation(
        cell_size=mp.Vector3(0, 0, LZ), dimensions=1, resolution=AUFL,
        boundary_layers=[mp.PML(DPML)], geometry=geom,
        sources=[mp.Source(mp.GaussianSource(F_RES, fwidth=0.05),
                           component=mp.Ex, center=mp.Vector3(0, 0, 0.31))])
    ts, es = [], []

    def messen(sim):
        ts.append(sim.meep_time())
        es.append(np.real(sim.get_field_point(mp.Ex, mp.Vector3(0, 0, 0.17))))

    sim.run(mp.after_sources(mp.at_every(0.25, messen)),
            until_after_sources=dauer)
    t, e = np.array(ts), np.array(es)
    n_f = int(4 / F_RES / 0.25)        # Fenster: vier Perioden
    mitten, amps = [], []
    for i0 in range(0, len(t) - n_f, n_f // 2):
        tw, ew = t[i0:i0 + n_f], e[i0:i0 + n_f]
        z = np.sum(ew * np.exp(-2j * np.pi * F_RES * tw))
        mitten.append(tw.mean())
        amps.append(2 * abs(z) / n_f)
    mitten, amps = np.array(mitten), np.array(amps)
    m = (amps > 1e-10) & (amps < 1e6)
    return np.polyfit(mitten[m], np.log(amps[m]), 1)[0]


rate_kalt = lockin_rate()
Q_abkling = 2 * np.pi * F_RES / (-2 * rate_kalt)
print(f"Klingelrate: {rate_kalt:.5f} pro Zeiteinheit")
print(f"Q aus dem Abklingen: {Q_abkling:.1f}   (aus der Linienbreite: 21,7)")
Klingelrate: -0.04236 pro Zeiteinheit
Q aus dem Abklingen: 21.9   (aus der Linienbreite: 21,7)

Beide Wege, ein \(Q\) — die Kapitel-15-Doppelmessung funktioniert auch hier. Und drinnen? Auf Resonanz speichert die Kavität Feld, bis die Verluste mit dem Nachschub gleichziehen. Wie viel, sagt die Echo-Reihe: Die umlaufende Amplitude ist um \(\sqrt{1-R}/(1-R)\) überhöht, und weil sich drinnen Hin- und Rückwelle zur Stehwelle addieren, kommt an den Bäuchen noch der Faktor \((1+\sqrt{R})\) dazu — macht \((1+\sqrt{R})\sqrt{1-R}/(1-R) = 3{,}0\) für unsere Spiegel:

# von oben: spiegel_geom(), LZ, DPML, AUFL, L, D_SP, F_RES, R_SP


def cw_profil(f):
    """Eingeschwungenes |Ex|(z) bei Dauerstrich-Anregung von links."""
    sim = mp.Simulation(
        cell_size=mp.Vector3(0, 0, LZ), dimensions=1, resolution=AUFL,
        boundary_layers=[mp.PML(DPML)], geometry=spiegel_geom(),
        force_complex_fields=True,
        sources=[mp.Source(mp.ContinuousSource(f), component=mp.Ex,
                           center=mp.Vector3(0, 0, -LZ / 2 + DPML + 0.5))])
    sim.run(until=400)
    ex = sim.get_array(component=mp.Ex, center=mp.Vector3(),
                       size=mp.Vector3(0, 0, LZ - 2 * DPML))
    z = np.linspace(-(LZ / 2 - DPML), LZ / 2 - DPML, len(ex))
    return z, ex


z_p, ex_on = cw_profil(F_RES)
_, ex_off = cw_profil(0.25)
innen = np.abs(ex_on)[np.abs(z_p) < L / 2 - 0.2].max()
davor = np.abs(ex_on)[(z_p < -L / 2 - D_SP - 0.3) & (z_p > -L / 2 - 2.5)].max()
ue_theo = (1 + np.sqrt(R_SP)) * np.sqrt(1 - R_SP) / (1 - R_SP)
print(f"Überhöhung auf Resonanz: {innen / davor:.2f}  (Theorie {ue_theo:.2f})")
innen_off = np.abs(ex_off)[np.abs(z_p) < L / 2 - 0.2].max()
print(f"zwischen den Resonanzen: innen nur noch "
      f"{innen_off / np.abs(ex_off).max():.2f} der Außenamplitude")
Überhöhung auf Resonanz: 2.86  (Theorie 3.00)
zwischen den Resonanzen: innen nur noch 0.33 der Außenamplitude
# von oben: z_p, ex_on, ex_off, L, D_SP
fig, ax = plt.subplots(figsize=(7.0, 4.0))
ax.axvspan(-L / 2 - D_SP, -L / 2, color="0.82")
ax.axvspan(L / 2, L / 2 + D_SP, color="0.82")
ax.plot(z_p, np.abs(ex_on), "C0-", lw=1.6,
        label=f"auf Resonanz (f = {F_RES})")
ax.plot(z_p, np.abs(ex_off), "C1-", lw=1.4, label="daneben (f = 0,25)")
ax.set_xlabel("z (graue Balken: die Spiegel)")
ax.set_ylabel("$|E_x|$")
ax.set_title("Die Kavität als Feldspeicher")
ax.legend(fontsize=9, loc="upper right")
ax.grid(alpha=0.3)
plt.show()
Abbildung 27.3: |E_x| entlang der Achse im eingeschwungenen Zustand (Spiegel grau): Auf Resonanz (blau) staut sich in der Kavität das Dreifache der Einfallsamplitude, und vor dem Resonator ist die Stehwellen-Riffelung fast verschwunden — er schluckt alles (T = 1). Zwischen den Resonanzen (orange) bleibt die Kavität fast leer, und draußen steht das volle Echo-Muster.

Diese Feldüberhöhung ist der eigentliche Beruf des Fabry-Pérot: LIGO speichert in seinen Arm-Kavitäten hunderte Kilowatt zirkulierender Lichtleistung aus wenigen Watt Laser — jede Faltung erhöht die Empfindlichkeit, als wäre der Arm hunderte Male so lang.

Der Film zeigt beide Fälle als laufende Welle (der Zeiger-Trick aus Kapitel 15): oben auf Resonanz, unten daneben. Sieh auf das Größenverhältnis innen/außen — und darauf, dass vor dem Resonator oben fast keine Stehwelle liegt (nichts kommt zurück), unten dagegen ein kräftiges Riffelmuster (fast alles kommt zurück).

Code der Animation (nur in der HTML-Fassung) 
# von oben: z_p, ex_on, ex_off, L, D_SP, F_RES
from matplotlib import animation
from IPython.display import HTML

phasen = np.linspace(0, 2 * np.pi, 16, endpoint=False)
fig, (a1, a2) = plt.subplots(2, 1, figsize=(7.2, 5.2), sharex=True)
y_max = 1.1 * np.abs(ex_on).max()
linien = []
for a, ex, beschr in [(a1, ex_on, f"f = {F_RES} — auf Resonanz"),
                      (a2, ex_off, "f = 0,25 — zwischen den Resonanzen")]:
    a.axvspan(-L / 2 - D_SP, -L / 2, color="0.82")
    a.axvspan(L / 2, L / 2 + D_SP, color="0.82")
    ln, = a.plot(z_p, np.real(ex), "C0-", lw=1.5)
    linien.append(ln)
    a.set_ylim(-y_max, y_max)
    a.set_ylabel("$E_x$")
    a.text(0.02, 0.06, beschr, transform=a.transAxes, fontsize=9)
a2.set_xlabel("z (graue Balken: die Spiegel)")
titel = a1.set_title("", fontsize=10)
fig.subplots_adjust(top=0.9, hspace=0.15)


def bild(i):
    zeiger = np.exp(-1j * phasen[i])
    linien[0].set_ydata(np.real(ex_on * zeiger))
    linien[1].set_ydata(np.real(ex_off * zeiger))
    titel.set_text("Feldspeicher oder Spiegel?\n"
                   f"t = {phasen[i] / (2 * np.pi):.2f} Perioden")
    return linien + [titel]


anim = animation.FuncAnimation(fig, bild, frames=len(phasen),
                               interval=140)
plt.close(fig)
HTML(anim.to_jshtml(default_mode="loop"))

Die Spielwiese macht dich zum Kamm-Designer — mit einer Zutat, die unser Meep-Modell nicht hatte: Verlust pro Umlauf (A_UMLAUF < 1, etwa Absorption oder Streuung). Drei Aufträge, erst vorhersagen: (1) R = 0.9 — was passiert mit Finesse und Spitzenhöhe? (2) L_KAV = 10 — was ändert sich am Kamm, was nicht? (3) A_UMLAUF = 0.95 bei R = 0.9: Warum brechen ausgerechnet die Spitzen ein, während der Rest des Kamms kaum leidet?

27.3 Der Ringresonator: Fabry-Pérot ohne Spiegel

Spiegel sind in der Optik Luxus — auf einem Photonik-Chip erst recht. Der elegante Ausweg: gar keine Spiegel. Biege einen Wellenleiter zum Kreis, und die Welle beißt sich selbst in den Schwanz. Resonanz herrscht, wann immer der Umfang eine ganze Zahl von Wellenlängen trägt — dann verstärkt sich die umlaufende Welle bei jedem Umlauf selbst, exakt wie zwischen zwei Spiegeln, nur ohne Umkehren. Die Rolle der Spiegelverluste übernimmt die Krümmung: Eine geführte Welle in der Kurve verliert ständig ein wenig Licht nach außen (die Glasfaser lässt grüßen — und Kapitel 12: Totalreflexion ist nur an der ebenen Grenzfläche perfekt).

Der Versuchsaufbau: Frage: Welche Moden lebt ein dielektrischer Ring, und wie gut hält er sie? Bühne: 2D, ein Ring mit Innenradius 1, Leiterbreite 1, \(n = 3{,}4\) (Silizium-Welt) in Luft; rundum PML. Anfangsbedingungen: ein Puls-Anstoß im Ringleiter. Messgrößen: Harminv (Kapitel 15) lauscht die Eigenfrequenzen samt \(Q\) heraus — hier funktioniert es, die Güten sind hoch genug. Erfolgskriterium: ein Frequenz-Kamm; und ein klarer Trend des \(Q\) über die Frequenz, den der nächste Absatz erklären soll.

Vorhersage-Punkt (PRIMM): Verliert die hochfrequente oder die tieffrequente Mode mehr Licht in der Kurve? Denk an Kapitel 17: Wie weit ragt der evaneszente Saum einer schwach geführten (= tieffrequenten) Welle aus dem Leiter hinaus?

# von oben: DPML
N_WG, W, R_IN = 3.4, 1.0, 1.0


def ring_moden(r_in, fcen=0.15, df=0.12):
    pad = 4.0
    s = 2 * (r_in + W + pad + DPML)
    geom = [mp.Cylinder(radius=r_in + W, material=mp.Medium(index=N_WG)),
            mp.Cylinder(radius=r_in, material=mp.air)]
    sim = mp.Simulation(
        cell_size=mp.Vector3(s, s), resolution=16,
        boundary_layers=[mp.PML(DPML)], geometry=geom,
        sources=[mp.Source(mp.GaussianSource(fcen, fwidth=df),
                           component=mp.Ez,
                           center=mp.Vector3(r_in + 0.1, 0.02))])
    h = mp.Harminv(mp.Ez, mp.Vector3(r_in + 0.12, -0.03), fcen, df)
    sim.run(mp.after_sources(h), until_after_sources=400)
    return sorted((m.freq, abs(m.Q)) for m in h.modes
                  if m.freq > 0.05 and abs(m.Q) > 20)


moden = ring_moden(R_IN)
for f_m, q_m in moden:
    print(f"f = {f_m:.4f}   Q = {q_m:7.0f}")
f = 0.1181   Q =      76
f = 0.1473   Q =     337
f = 0.1756   Q =    2069
f = 0.2036   Q =    5015

Ein Kamm — der FSR von etwa 0,028 ist wieder die Umlauf-Frequenz, diesmal über den Umfang statt über \(2L\). Und das \(Q\) explodiert nach oben: von 76 auf 5000 innerhalb von vier Zähnen. Die Antwort auf den Vorhersage-Punkt: Die tieffrequente Mode leidet — ihr evaneszenter Saum ragt weit aus dem Leiter, und was weit draußen mitlaufen soll, müsste in der Kurve schneller als das Licht unterwegs sein. Diesen Teil verliert der Ring unweigerlich. Höhere Frequenz = engerer Saum = exponentiell dichter eingesperrt; die Biege-Übung am Kapitelende macht daraus eine Messreihe.

27.3.1 Der Ring am Bus

Ein einsamer Ring nützt niemandem — man muss Licht hinein- und herausbekommen, ohne ihn zu berühren. Das Werkzeug dafür haben wir in Übung 17.4 vermessen: Liegen zwei Leiter nah beieinander, hüpft Leistung durch die evaneszenten Säume hinüber (der Richtkoppler — dort als Vorgriff auf genau dieses Kapitel angekündigt). Also legen wir einen geraden Bus-Wellenleiter im Abstand \(g\) am Ring vorbei und schicken einen Puls hindurch. Frage: Was sieht der Bus von den Ringmoden? Messgröße: \(T(f)\) am Bus-Ausgang, normiert auf den Lauf ohne Ring. Erfolgskriterium: Auffälligkeiten genau an den Harminv-Frequenzen von oben.

# von oben: N_WG, W, R_IN, DPML, moden


def bus_sweep(spalt, mit_ring, fcen, df):
    pad = 3.0
    sx = 2 * (R_IN + W + pad + DPML)
    y_bus = -(R_IN + W + spalt + W / 2)
    geom = [mp.Block(size=mp.Vector3(mp.inf, W, mp.inf),
                     center=mp.Vector3(0, y_bus),
                     material=mp.Medium(index=N_WG))]
    if mit_ring:
        geom += [mp.Cylinder(radius=R_IN + W, material=mp.Medium(index=N_WG)),
                 mp.Cylinder(radius=R_IN, material=mp.air)]
    sim = mp.Simulation(
        cell_size=mp.Vector3(sx, sx), resolution=16,
        boundary_layers=[mp.PML(DPML)], geometry=geom,
        sources=[mp.Source(mp.GaussianSource(fcen, fwidth=df),
                           component=mp.Ez,
                           center=mp.Vector3(-sx / 2 + DPML + 0.5, y_bus),
                           size=mp.Vector3(0, 2 * W))])
    x_m = sx / 2 - DPML - 0.5
    tr = sim.add_flux(fcen, df, 401,
                      mp.FluxRegion(center=mp.Vector3(x_m, y_bus),
                                    size=mp.Vector3(0, 2 * W)))
    sim.run(until_after_sources=mp.stop_when_fields_decayed(
        100, mp.Ez, mp.Vector3(x_m, y_bus), 1e-8))
    return np.array(mp.get_flux_freqs(tr)), np.array(mp.get_fluxes(tr))


fs_r, P0r = bus_sweep(0.2, False, 0.15, 0.10)
_, P1r = bus_sweep(0.2, True, 0.15, 0.10)
T_ring = P1r / P0r

from scipy.signal import argrelmin   # lokale Minima
dips = [i for i in argrelmin(T_ring)[0]
        if T_ring[i] < 0.7 and 0.11 < fs_r[i] < 0.19]
print("Dips bei:", np.round(fs_r[dips], 4))
print("Ringmoden:", np.round([m[0] for m in moden[:3]], 4))
Dips bei: [0.1212 0.1485 0.1755]
Ringmoden: [0.1181 0.1473 0.1756]
# von oben: fs_r, T_ring, moden
fig, ax = plt.subplots(figsize=(7.0, 4.0))
ax.plot(fs_r, T_ring, "C0-", lw=1.5)
for f_m, _ in moden[:3]:
    ax.axvline(f_m, color="0.55", ls=":", lw=1.2)
ax.set_xlabel("Frequenz  $f\\,a/c$")
ax.set_ylabel("Transmission $T$ im Bus")
ax.set_title("Der Ring nascht am Bus — aber nur auf Resonanz")
ax.set_xlim(0.10, 0.20)
ax.set_ylim(0, 1.05)
ax.grid(alpha=0.3)
plt.show()
Abbildung 27.4: Transmission im Bus-Wellenleiter: scharfe Dips exakt an den Ringmoden (gepunktete Linien aus der Harminv-Messung). Bei diesen Frequenzen saugt der Ring die Leistung aus dem Bus und verstrahlt sie über seinen Biegeverlust — alle anderen Frequenzen laufen ungerührt vorbei. Ein Kerbfilter, periodisch wie der Resonator selbst.

Was im Ring selbst los ist, zeigt der Dauerstrich-Blick auf den mittleren Dip — und beantwortet nebenbei, welche azimutale Modenzahl \(m\) (wie viele Wellenlängen auf dem Umfang?) dort schwingt. Statt Bäuche zu zählen, lassen wir die Phase zählen: Auf einem Kreis durch den Ringleiter muss \(\arg E_z\) insgesamt \(m\) volle Umdrehungen machen — np.unwrap (setzt Phasensprünge von \(\pm\pi\) zu einer stetigen Kurve zusammen) macht daraus eine einzige Zahl.

# von oben: N_WG, W, R_IN, DPML
SPALT = 0.2
pad = 3.0
sx_cw = 2 * (R_IN + W + pad + DPML)
y_bus = -(R_IN + W + SPALT + W / 2)
geom_cw = [mp.Block(size=mp.Vector3(mp.inf, W, mp.inf),
                    center=mp.Vector3(0, y_bus),
                    material=mp.Medium(index=N_WG)),
           mp.Cylinder(radius=R_IN + W, material=mp.Medium(index=N_WG)),
           mp.Cylinder(radius=R_IN, material=mp.air)]
sim_cw = mp.Simulation(
    cell_size=mp.Vector3(sx_cw, sx_cw), resolution=16,
    boundary_layers=[mp.PML(DPML)], geometry=geom_cw,
    force_complex_fields=True,
    sources=[mp.Source(mp.ContinuousSource(0.1485), component=mp.Ez,
                       center=mp.Vector3(-sx_cw / 2 + DPML + 0.5, y_bus),
                       size=mp.Vector3(0, 2 * W))])
sim_cw.run(until=600)
seite_cw = 2 * (R_IN + W) + 2.5
ez_ring = sim_cw.get_array(component=mp.Ez,
                           center=mp.Vector3(0, y_bus / 2),
                           size=mp.Vector3(seite_cw, seite_cw + abs(y_bus)))
print(f"Gesundheitswert: max|Ez| = {np.abs(ez_ring).max():.2f}")

# Phasenwindung auf dem Kreis durch die Leitermitte
nx, ny = ez_ring.shape
xs = np.linspace(-seite_cw / 2, seite_cw / 2, nx)
ys = np.linspace(y_bus / 2 - (seite_cw + abs(y_bus)) / 2,
                 y_bus / 2 + (seite_cw + abs(y_bus)) / 2, ny)
rm = R_IN + W / 2
winkel = np.linspace(0, 2 * np.pi, 720, endpoint=False)
ring_werte = np.array([
    ez_ring[np.argmin(np.abs(xs - rm * np.cos(p))),
            np.argmin(np.abs(ys - rm * np.sin(p)))] for p in winkel])
phase = np.unwrap(np.angle(ring_werte))   # Phasenspruenge glaetten
print(f"azimutale Modenzahl m = {(phase[-1] - phase[0]) / (2 * np.pi):.2f}")

fig, ax = plt.subplots(figsize=(6.4, 6.6))
ax.imshow(np.abs(ez_ring).T, origin="lower", cmap="inferno",
          extent=[xs[0], xs[-1], ys[0], ys[-1]],
          vmax=np.percentile(np.abs(ez_ring), 99.5))
ax.add_patch(plt.Circle((0, 0), R_IN + W, fill=False, color="w",
                        lw=0.5, alpha=0.6))
ax.add_patch(plt.Circle((0, 0), R_IN, fill=False, color="w",
                        lw=0.5, alpha=0.6))
ax.set_xlabel("x/a")
ax.set_ylabel("y/a")
ax.set_title("Die umlaufende Mode (m = 4)")
plt.show()
Gesundheitswert: max|Ez| = 0.71
azimutale Modenzahl m = 4.00
Abbildung 27.5: |E_z| im eingeschwungenen Zustand bei f = 0,1485 (Dauerstrich im Bus, der unten im Bild liegt): Der Ring leuchtet auf ganzer Länge fast gleichmäßig — das Kennzeichen einer laufenden Welle (eine Stehwelle hätte dunkle Knoten). Die Phasenmessung entlang des Rings ergibt m = 4,00: exakt vier Wellenlängen auf dem Umfang.

Im Film läuft sie wirklich: das Momentanbild \(\operatorname{Re}(E_z \mathrm{e}^{-\mathrm{i}\varphi})\) über eine Periode. Die vier Wellenzüge rotieren als geschlossener Kreisverkehr — gespeist vom Bus unten, der Drehsinn folgt der Laufrichtung der Bus-Welle.

Code der Animation (nur in der HTML-Fassung) 
# von oben: ez_ring, xs, ys, R_IN, W
phasen_2d = np.linspace(0, 2 * np.pi, 16, endpoint=False)
vmax_f = np.percentile(np.abs(ez_ring), 99.5)

fig, ax = plt.subplots(figsize=(6.4, 6.6))
bildobj = ax.imshow(np.real(ez_ring).T, origin="lower", cmap="RdBu_r",
                    extent=[xs[0], xs[-1], ys[0], ys[-1]],
                    vmin=-vmax_f, vmax=vmax_f)
ax.add_patch(plt.Circle((0, 0), R_IN + W, fill=False, color="0.3",
                        lw=0.5, alpha=0.6))
ax.add_patch(plt.Circle((0, 0), R_IN, fill=False, color="0.3",
                        lw=0.5, alpha=0.6))
ax.set_xlabel("x/a")
ax.set_ylabel("y/a")
titel_r = ax.set_title("", fontsize=10)
fig.subplots_adjust(top=0.93)


def bild_ring(i):
    bildobj.set_data(np.real(ez_ring * np.exp(-1j * phasen_2d[i])).T)
    titel_r.set_text("Kreisverkehr mit vier Wellenzügen — "
                     f"t = {phasen_2d[i] / (2 * np.pi):.2f} Perioden")
    return [bildobj, titel_r]


anim_r = animation.FuncAnimation(fig, bild_ring, frames=len(phasen_2d),
                                 interval=140)
plt.close(fig)
HTML(anim_r.to_jshtml(default_mode="loop"))

27.4 Kritische Kopplung: der perfekt schwarze Dip

Der Dip bei 0,1485 erreichte \(T \approx 0{,}29\) — ordentlich, aber kein schwarzes Loch. Liegt es am Abstand? Rücken wir den Bus doch näher an den Ring, dann koppelt mehr.

Vorhersage-Punkt (PRIMM): Wir fahren den Spalt \(g\) von 0,2 bis 1,3 durch. Wird der Dip mit kleinerem Spalt (stärkerer Kopplung) monoton tiefer — je näher, desto schwärzer?

# von oben: bus_sweep()
SPALTE = [0.2, 0.4, 0.7, 1.0, 1.3]
T_min_g = []
for g in SPALTE:
    fg, p0 = bus_sweep(g, False, 0.149, 0.02)
    _, p1 = bus_sweep(g, True, 0.149, 0.02)
    T_min_g.append(float((p1 / p0).min()))
    print(f"Spalt g = {g}:  T_min = {T_min_g[-1]:.4f}")
Spalt g = 0.2:  T_min = 0.2859
Spalt g = 0.4:  T_min = 0.0565
Spalt g = 0.7:  T_min = 0.3255
Spalt g = 1.0:  T_min = 0.7651
Spalt g = 1.3:  T_min = 0.9399
# von oben: SPALTE, T_min_g
fig, ax = plt.subplots(figsize=(6.6, 4.0))
ax.plot(SPALTE, T_min_g, "C0o-", ms=7, lw=1.4)
ax.axvline(0.4, color="0.4", ls="--", lw=1.2)
ax.annotate("kritisch", (0.4, 0.5), xytext=(0.55, 0.55), fontsize=10,
            arrowprops=dict(arrowstyle="->", color="0.3"))
ax.text(0.21, 0.32, "überkoppelt", fontsize=9, color="0.35")
ax.text(0.95, 0.6, "unterkoppelt", fontsize=9, color="0.35")
ax.set_xlabel("Koppelspalt $g$")
ax.set_ylabel("Dip-Tiefe $T_{\\min}$")
ax.set_title("Kritische Kopplung: das V der Anpassung")
ax.set_ylim(0, 1)
ax.grid(alpha=0.3)
plt.show()
Abbildung 27.6: Die Tiefe des Transmissions-Dips über dem Koppelspalt: kein monotoner Verlauf, sondern ein V mit Minimum bei g = 0,4 (gestrichelt) — dort schluckt der Ring praktisch alles (T = 0,06). Links davon ist die Kopplung stärker als der Ringverlust (überkoppelt), rechts schwächer (unterkoppelt); ganz rechts merkt der Bus den Ring kaum noch.

Nein — die Kurve ist ein V. Der Dip wird erst tiefer, erreicht bei \(g = 0{,}4\) fast die Null und füllt sich dann wieder. Dahinter steckt ein Wettkampf zweier Verlustkanäle: Der Ring verliert Licht durch seine Krümmung (Eigenverlust, fest) und zurück in den Bus (Koppelverlust, über \(g\) einstellbar). Was der Bus hinter dem Ring sieht, ist die Interferenz der direkt durchgelaufenen Welle mit dem Anteil, der den Ring besucht hat — und diese beiden löschen sich exakt aus, wenn beide Kanäle gleich stark sind: kritische Kopplung. Das ist Leistungsanpassung, Kapitel 22, nur in der Optik: Quelle und Verbraucher (hier: Biegeverlust) müssen zueinander passen, sonst bleibt Echo übrig. Und es ist derselbe Mechanismus, mit dem in Kapitel 15 das Koppel-Loch die Güte des Hohlraums regelte — dort haben wir den Resonator be- und entlüftet, hier stimmen wir ihn auf seinen eigenen Verlust ab.

Genau auf diesem V steht die Silizium-Photonik: Ein Ring nahe der kritischen Kopplung ist ein extrem empfindlicher Schalter. Verschiebt man seine Resonanz nur um eine Linienbreite — etwa indem Ladungsträger den Brechungsindex minimal ändern —, springt \(T\) am Arbeitspunkt zwischen fast 0 und fast 1: ein Ring-Modulator, das Bauteil, das in Rechenzentren elektrische Bits auf Licht prägt. Dieselbe Empfindlichkeit macht den Ring zum Biosensor: Ein Protein, das auf der Oberfläche andockt, verstimmt die Resonanz messbar.

27.5 Der Schritt zum Laser

Ein Resonator speichert Licht und verliert es langsam wieder — Rate \(\omega/2Q\), gemessen. Was, wenn wir den Verlust nicht nur ausgleichen, sondern überbieten? Seit Kapitel 19 wissen wir, was dann passieren muss: Ein schwingungsfähiges System mit Energiezufuhr, die schneller nachschiebt als die Dämpfung zehrt, ist ein selbsterregter Oszillator — dort war es der van-der-Pol-Kreis an der Messerschneide \(k = R\). Ein Laser ist exakt das: Resonator (haben wir) plus verstärkendes Medium (kommt jetzt).

Verstärkung bekommt Meep verblüffend billig: Kapitel 15 hat vermessen, dass D_conductivity \(= \sigma\) das Feld mit der Rate \(\sigma/2\) dämpft — also verstärkt ein negatives \(\sigma\) mit derselben Rate. Erst die Eichung im homogenen Medium (Versuchsaufbau: periodische 1D-Zelle, laufende Welle, ein Anstoß; Erfolgskriterium: Wachstumsrate exakt \(\sigma/2\)):

# von oben: AUFL
sim_h = mp.Simulation(
    cell_size=mp.Vector3(0, 0, 4), dimensions=1, resolution=AUFL,
    k_point=mp.Vector3(0, 0, 0.25),
    default_material=mp.Medium(D_conductivity=-0.05),
    sources=[mp.Source(mp.GaussianSource(0.25, fwidth=0.1),
                       component=mp.Ex, center=mp.Vector3(0, 0, 0.3))])
werte_h = []
sim_h.run(mp.after_sources(mp.at_every(0.5, lambda s: werte_h.append(
    (s.meep_time(), abs(s.get_field_point(mp.Ex, mp.Vector3(0, 0, 1.1))))))),
    until_after_sources=150)
t_h = np.array([w[0] for w in werte_h])
a_h = np.array([w[1] for w in werte_h])
m_h = a_h > 1e-12
print(f"Wachstumsrate: {np.polyfit(t_h[m_h], np.log(a_h[m_h]), 1)[0]:.5f}"
      f"   (sigma/2 = 0.02500)")
Wachstumsrate: 0.02500   (sigma/2 = 0.02500)

Exakt. Jetzt das eigentliche Experiment. Frage: Bei welchem \(\sigma\) springt der Resonator an? Die Vorhersage steht schon da: Die kalte Klingelrate war \(-0{,}0424\) — Verstärkung gewinnt, sobald \(\sigma/2\) das übertrifft, also bei \(\sigma_{\text{th}} \approx 0{,}085\). Bühne: die FP-Kavität, gefüllt mit Gain-Medium; ein winziger Anstoß; dann messen wir die Lock-in-Rate der Mode für eine \(\sigma\)-Reihe. Erfolgskriterium: Raten auf einer Geraden, Nulldurchgang an der Vorhersage.

Und hier rettet uns der Lock-in tatsächlich den Hals (Werkstatt-Notiz): Die Gauß-Stromquelle hinterlässt in 1D ein winziges statisches Restfeld (ihr Strom-Integral ist nicht exakt null). Ein normaler Resonatorlauf merkt das nie — aber ein Gain-Medium verstärkt auch Gleichfelder, ohne jeden Spiegelverlust, und nach hundert Zeiteinheiten dominiert der wachsende DC-Sockel jede naive Hüllkurvenmessung. Der Lock-in auf \(f_{\text{res}}\) ist dafür taub.

# von oben: lockin_rate(), rate_kalt
sig_naiv = -2 * rate_kalt
SIGS = np.array([0.0, 0.5, 0.8, 1.0, 1.2, 1.5]) * sig_naiv
raten = np.array([rate_kalt] + [lockin_rate(s) for s in SIGS[1:]])
for s_v, r_v in zip(SIGS, raten):
    print(f"sigma = {s_v:.4f}:  Rate = {r_v:+.5f}")

iw = int(np.flatnonzero(raten > 0)[0])
sig_th = SIGS[iw - 1] - raten[iw - 1] * (SIGS[iw] - SIGS[iw - 1]) \
    / (raten[iw] - raten[iw - 1])
print(f"\nSchwelle (Nulldurchgang): sigma_th = {sig_th:.4f}")
print(f"Vorhersage 2 x kalte Rate: {sig_naiv:.4f}  "
      f"(Abweichung {100 * (sig_th / sig_naiv - 1):+.1f} %)")
sigma = 0.0000:  Rate = -0.04236
sigma = 0.0424:  Rate = -0.02314
sigma = 0.0678:  Rate = -0.01128
sigma = 0.0847:  Rate = -0.00290
sigma = 0.1017:  Rate = +0.00609
sigma = 0.1271:  Rate = +0.02465

Schwelle (Nulldurchgang): sigma_th = 0.0902
Vorhersage 2 x kalte Rate: 0.0847  (Abweichung +6.4 %)
# von oben: SIGS, raten, sig_th, sig_naiv, rate_kalt
fig, ax = plt.subplots(figsize=(6.6, 4.0))
ax.plot(SIGS, raten, "C0o", ms=7, label="Meep (Lock-in-Rate)")
sgrid = np.linspace(0, SIGS[-1], 50)
ax.plot(sgrid, rate_kalt + sgrid / 2, "0.4", ls=":", lw=1.3,
        label="Referenz: kalte Rate + $\\sigma/2$")
ax.axvline(sig_naiv, color="0.4", ls="--", lw=1.2,
           label="2 × kalte Verlustrate")
ax.axhline(0, color="0.6", lw=1)
ax.plot([sig_th], [0], "C3*", ms=14, label=f"Schwelle {sig_th:.4f}")
ax.set_xlabel("Verstärkung $\\sigma$")
ax.set_ylabel("Wachstumsrate des Feldes")
ax.set_title("Der Laser springt am Verlustgleichstand an")
ax.legend(fontsize=8, loc="upper left")
ax.grid(alpha=0.3)
plt.show()
Abbildung 27.7: Die Wachstumsrate der Resonatormode über der Verstärkung: unterhalb der Schwelle klingt jeder Anstoß ab, oberhalb schaukelt er sich exponentiell auf. Der Nulldurchgang liegt sechs Prozent über der einfachen Vorhersage „2 × kalte Verlustrate“ (gestrichelt) — die Mode wohnt zu einem Teil in den Spiegeln, wo nichts verstärkt. Die Steigungs-Referenz σ/2 (gepunktet) trifft den Verlauf nahe der Schwelle.

Oberhalb der Schwelle wächst das Feld in unserer Simulation unbegrenzt — exponentiell, für immer. Ein echter Laser tut das offensichtlich nicht, und was fehlt, kennt Kapitel 19 genau: die Sättigung. Reale Verstärkung speist sich aus angeregten Atomen, und je stärker das Feld, desto schneller räumt es sie ab — die Verstärkung sinkt mit der Intensität, \(G = G_0/(1 + I/I_{\text{sat}})\). Genau wie beim van-der-Pol-Oszillator stabilisiert das die Amplitude: Das Feld wächst, bis die gesättigte Verstärkung die Verluste exakt deckt, und bleibt dort — der Grenzzyklus. Ein Umlauf-Modell mit dieser einen Zutat liefert die berühmteste Kurve der Laserphysik:

# Umlauf-Modell: pro Umlauf Verstaerkung (gesaettigt), dann Verlust
def stationaere_intensitaet(G0, verlust=0.2, n_umlauf=4000):
    I = 1e-9                       # winziger Anstoss ("Rauschen")
    for _ in range(n_umlauf):
        I = I * (1 + G0 / (1 + I)) * (1 - verlust)
    return I


G_reihe = np.linspace(0.05, 0.6, 23)
I_stat = np.array([stationaere_intensitaet(G) for G in G_reihe])
V = 0.2
G_schwelle = V / (1 - V)
I_theo = np.maximum(0.0, G_reihe * (1 - V) / V - 1)

fig, ax = plt.subplots(figsize=(6.6, 4.0))
ax.plot(G_reihe, I_stat, "C0o", ms=6, label="Umlauf-Modell (4000 Umläufe)")
ax.plot(G_reihe, I_theo, "C1-", lw=1.5, label="stationäre Lösung")
ax.axvline(G_schwelle, color="0.4", ls="--", lw=1.2,
           label=f"Schwelle $G_0$ = {G_schwelle:.2f}")
ax.set_xlabel("Kleinsignal-Verstärkung $G_0$ pro Umlauf")
ax.set_ylabel("stationäre Intensität $I/I_{sat}$")
ax.set_title("Die Laser-Kennlinie: aus — Knick — an")
ax.legend(fontsize=9, loc="upper left")
ax.grid(alpha=0.3)
plt.show()
Abbildung 27.8: Die Laser-Kennlinie aus dem Umlauf-Modell (Punkte): Unterhalb der Schwelle bleibt die stationäre Intensität null — alles Klingeln stirbt aus. An der Schwelle (Verstärkung = Verlust) knickt die Kurve scharf ab und steigt dann linear: Jedes zusätzliche Quäntchen Pumpleistung wird zu Licht. Die Linie ist die stationäre Lösung G₀/(1+I) · (1−V) = V von Hand.

In der Spielwiese siehst du das Einschwingen selbst — drei Vorhersagen vorab: (1) Bei G0 = 0.2 (unter der Schwelle 0,25): Wie endet die Kurve? (2) Bei G0 = 0.3 und G0 = 0.5: Worauf laufen beide zu, und was unterscheidet den Weg dorthin? (3) Verdopple I_START — ändert sich das Ende? (Der Witz des Grenzzyklus aus Kapitel 19: Das Ziel hängt nicht vom Start ab.)

Mehr als dieses Umlauf-Modell und die Schwellen-Messung soll der Ausblick nicht behaupten: Ein echter Laser hat Atome mit Niveaus, spektral geformte Verstärkung und Rauschen, das die allererste Welle liefert. Aber die Architektur steht komplett im Buch: Resonator (Kapitel 15/27) + gesättigte Verstärkung (Kapitel 19) = Oszillator für Licht. Und der Frequenz-Kamm erklärt eine letzte Alltagsbeobachtung: Ein Laser schwingt nicht auf „einer Farbe”, sondern auf den Kammzähnen, die in sein Verstärkungsfenster fallen — bei einem Helium-Neon-Rohr sind das typisch zwei, drei Längsmoden (Übung 27.1).

27.6 Das Kapitel-Programm

programme/kap27/kap27_ringresonator_fabryperot.py bündelt alle Befunde eigenständig und mit assert-Schranken: die Phasenuhr-Probe und Echo-Summe == TMM == Airy (je \(10^{-15}\)), Kamm (FSR 0,0892, \(L_{\text{eff}} = 5{,}61\), Finesse 6,6), den Meep-Sweep (rms 0,0014), das doppelte \(Q\) (21,9/21,7), die Feldüberhöhung (2,86 vs. 3,0), die homogene Gain-Eichung (\(\sigma/2\) exakt), die Laser-Schwelle (±10 % am Verlustgleichstand), die Ringmoden samt monotonem Biege-\(Q\), die Bus-Dips auf den Modenfrequenzen, das V der kritischen Kopplung und den Kennlinien-Knick. Läuft in wenigen Minuten.

TippMerkkasten
  • Fabry-Pérot = Echo-Summe: geometrische Reihe der Umläufe; auf Resonanz löscht das Kavitätsleck die Reflexion aus → \(T = 1\) durch zwei 64-%-Spiegel. Kamm mit \(\mathrm{FSR} = c/2L_{\text{eff}}\) (die Welle wohnt ein Stück im Spiegel), Trennschärfe = Finesse \(\pi\sqrt{R}/(1-R)\).
  • Im Resonator staut sich Feld: Überhöhung \((1+\sqrt{R})\sqrt{1-R}/(1-R)\) — der Grund, warum LIGO und Laserkavitäten falten statt verlängern.
  • Ring = Fabry-Pérot ohne Spiegel: Resonanz, wenn der Umfang \(m\) Wellenlängen trägt; Verlustkanal ist die Krümmung (Biege-\(Q\) wächst exponentiell mit Radius und Frequenz); Ankopplung evaneszent über den Kapitel-17-Richtkoppler.
  • Kritische Kopplung: Der Bus-Dip wird genau dann schwarz, wenn Koppelverlust = Eigenverlust — Leistungsanpassung (Kapitel 22) in der Photonik; Arbeitspunkt von Modulatoren und Sensoren.
  • Laser = Resonator + gesättigte Verstärkung: Schwelle exakt am Verlustgleichstand (gemessen); die Sättigung macht aus exponentiellem Wachstum einen Grenzzyklus (Kapitel 19) — daher der Knick der Kennlinie.

Roter Faden

Dieses Kapitel ist ein Sammelbecken: die Echo-Geometrie aus Kapitel 6/22 (geometrische Reihe — von der Lampen-Treppe zum Airy-Kamm), die Transfer-Matrix und Defektnadel aus Kapitel 26 (Übung 26.3 war dieses Kapitel im Kleinformat), Güte und Harminv aus Kapitel 15 (Q dreifach, Koppel-Loch → kritische Kopplung), der Richtkoppler aus Kapitel 17 (Zusage eingelöst: er speist jetzt Ringe), die Anpassung aus Kapitel 22 (kritische Kopplung als optisches SWR = 1) und der van-der-Pol-Oszillator aus Kapitel 19 (Schwelle, Sättigung, Grenzzyklus — jetzt mit Licht). Nach vorn: Kapitel 28 fragt, was passiert, wenn man Materialien selbst zu Schaltungen macht — Metamaterialien, negativer Brechungsindex und Doppelbrechung; der Ringresonator kehrt dort als Baustein zurückgerollter Wellen nicht wieder, wohl aber die Frage, wie weit man \(\varepsilon\) und \(\mu\) verbiegen darf.

Übungen

Ü 27.1 — Kammzählen im Gerätepark (Verstehen). Rechne den freien Spektralbereich dreier realer Resonatoren aus (\(\mathrm{FSR} = c/(2 n L)\)): (a) eine Laserdiode (\(L = 0{,}3\) mm, \(n = 3{,}5\)), (b) ein Helium-Neon-Laser (\(L = 30\) cm, \(n \approx 1\)) — wie viele Längsmoden passen in sein 1,5 GHz breites Verstärkungsfenster? (c) ein LIGO-Arm (\(L = 4\) km). Was bedeutet das winzige FSR von (c) praktisch?

C = 299792458.0
for name, L_r, n_r in [("Laserdiode", 0.3e-3, 3.5),
                       ("HeNe-Rohr", 0.30, 1.0),
                       ("LIGO-Arm", 4000.0, 1.0)]:
    fsr = C / (2 * n_r * L_r)
    print(f"{name:11s}: FSR = {fsr:.3e} Hz")
print(f"\nHeNe: {1.5e9 / (C / (2 * 0.30)):.1f} Moden im Gain-Fenster")
Laserdiode : FSR = 1.428e+11 Hz
HeNe-Rohr  : FSR = 4.997e+08 Hz
LIGO-Arm   : FSR = 3.747e+04 Hz

HeNe: 3.0 Moden im Gain-Fenster
  1. Die Laserdiode hat 143 GHz Modenabstand — ihr Verstärkungsfenster ist zwar Terahertz breit, aber mit Tricks (Gitter, DFB) zwingt man sie auf einen einzigen Zahn. (b) Beim HeNe passen drei Moden ins Fenster: Ein gewöhnlicher Laborlaser schwingt auf zwei bis drei Frequenzen gleichzeitig, die um 500 MHz auseinanderliegen — sichtbar als Schwebung auf einer schnellen Photodiode.
  2. LIGOs 37,5 kHz bedeuten: Der Kamm ist so fein, dass der Laser aktiv auf einem Zahn festgenagelt werden muss (Pound-Drever-Hall-Regelung) — die Kavität ist dort Lineal, nicht Filter.

Ü 27.2 — Die Finesse-Reihe (Verändern). Variiere die Spiegeldicke (\(0{,}3\) bis \(1{,}0\) × λ/4) und miss mit der Transfer-Matrix Finesse und Spitzenhöhe des Kamms. Lege \(\pi\sqrt{R}/(1-R)\) als Theorielinie darüber (\(R\) jeweils des Einzelspiegels bei \(f_0\)). Wo weicht die Messung ab, und in welche Richtung?

# von oben: schichtmatrix(), rt_von(), F0, N_SP, D_SP, L


def kamm_finesse(dicke_faktor):
    d = dicke_faktor * D_SP

    def T_f(f):
        M = schichtmatrix(N_SP, d, f) @ schichtmatrix(1.0, L, f) \
            @ schichtmatrix(N_SP, d, f)
        return np.abs(rt_von(M)[1])**2

    f_raster = np.linspace(0.15, 0.35, 4001)
    Tk = np.array([T_f(f) for f in f_raster])
    iks = [i for i in argrelmax(Tk)[0] if Tk[i] > 0.5]
    # FWHM an der Resonanz nächst f0 messen — nicht am Rasterrand!
    ip = iks[int(np.argmin(np.abs(f_raster[iks] - F0)))]
    ueber = Tk > Tk[ip] / 2
    lo = hi = ip
    while lo > 0 and ueber[lo - 1]:
        lo -= 1
    while hi < len(Tk) - 1 and ueber[hi + 1]:
        hi += 1
    fsr_l = float(np.diff(f_raster[iks]).mean())
    return fsr_l / (f_raster[hi] - f_raster[lo])


fakt = np.array([0.3, 0.45, 0.6, 0.8, 1.0])
fin_mess = [kamm_finesse(fk) for fk in fakt]
R_reihe = np.array([np.abs(rt_von(schichtmatrix(N_SP, fk * D_SP, F0))[0])**2
                    for fk in fakt])
fin_theo = np.pi * np.sqrt(R_reihe) / (1 - R_reihe)

fig, ax = plt.subplots(figsize=(6.4, 3.8))
ax.plot(R_reihe, fin_mess, "C0o", ms=7, label="Transfer-Matrix-Kamm")
ax.plot(R_reihe, fin_theo, "C1-", lw=1.5,
        label="ideal: $\\pi\\sqrt{R}/(1-R)$")
ax.set_xlabel("Spiegelreflexion $R$ (bei $f_0$)")
ax.set_ylabel("Finesse")
ax.set_title("Trennschärfe wächst mit dem Spiegel")
ax.legend(fontsize=9)
ax.grid(alpha=0.3)
plt.show()

Gemessene Finesse (Punkte) gegen die Idealformel (Linie): Die Messung liegt durchweg leicht darunter, und der Abstand wächst mit R. Grund ist die Frequenzabhängigkeit der realen Spiegel — über die (schmaler werdende) Linie ist R nicht konstant und die Reflexionsphase dreht sich mit; die Idealformel kennt beides nicht.

Die Messpunkte liegen systematisch unter der Idealkurve (bei \(R = 0{,}64\): 6,5 statt 7,0). Die Formel nimmt an, dass \(R\) und die Spiegelphase über die Resonanzlinie konstant sind — echte (dispersive) Spiegel verschmieren die Linie zusätzlich. Die Lehre ist dieselbe wie bei der Dickdraht-Antenne in Kapitel 21: Idealformeln sind Leitplanken, die Bauteile dahinter haben Charakter.

Ü 27.3 — Die Kanalweiche (Übertragen). Lege einen zweiten Bus-Wellenleiter oben an den Ring (gleicher Spalt 0,2) und miss beide Ausgänge: die Transmission im unteren Bus und die Leistung, die im oberen Bus herauskommt (Add-Drop-Filter). Zwei Vorhersagen, bevor du startest: Was passiert auf Resonanz mit der Leistung — und aus welchem Ende des oberen Leiters kommt sie heraus? (Verfolge den Drehsinn des Kreisverkehrs: Die Bus-Welle läuft nach rechts und gibt ihn dem Ring vor.)

# von oben: N_WG, W, R_IN, DPML, bus_sweep()
SPALT3 = 0.2
pad3 = 3.0
sx3 = 2 * (R_IN + W + pad3 + DPML)
y_unten = -(R_IN + W + SPALT3 + W / 2)
y_oben = +(R_IN + W + SPALT3 + W / 2)
geom3 = [mp.Block(size=mp.Vector3(mp.inf, W, mp.inf),
                  center=mp.Vector3(0, y_unten),
                  material=mp.Medium(index=N_WG)),
         mp.Block(size=mp.Vector3(mp.inf, W, mp.inf),
                  center=mp.Vector3(0, y_oben),
                  material=mp.Medium(index=N_WG)),
         mp.Cylinder(radius=R_IN + W, material=mp.Medium(index=N_WG)),
         mp.Cylinder(radius=R_IN, material=mp.air)]
sim3 = mp.Simulation(
    cell_size=mp.Vector3(sx3, sx3), resolution=16,
    boundary_layers=[mp.PML(DPML)], geometry=geom3,
    sources=[mp.Source(mp.GaussianSource(0.149, fwidth=0.02),
                       component=mp.Ez,
                       center=mp.Vector3(-sx3 / 2 + DPML + 0.5, y_unten),
                       size=mp.Vector3(0, 2 * W))])
x_m3 = sx3 / 2 - DPML - 0.5
tr_durch = sim3.add_flux(0.149, 0.02, 401,
                         mp.FluxRegion(center=mp.Vector3(x_m3, y_unten),
                                       size=mp.Vector3(0, 2 * W)))
# Drop-Port LINKS oben: weight=-1 zaehlt den Fluss nach -x positiv
tr_drop = sim3.add_flux(0.149, 0.02, 401,
                        mp.FluxRegion(center=mp.Vector3(-x_m3, y_oben),
                                      size=mp.Vector3(0, 2 * W), weight=-1))
sim3.run(until_after_sources=mp.stop_when_fields_decayed(
    100, mp.Ez, mp.Vector3(x_m3, y_unten), 1e-8))

fs3 = np.array(mp.get_flux_freqs(tr_durch))
_, P0_3 = bus_sweep(SPALT3, False, 0.149, 0.02)
T_durch = np.array(mp.get_fluxes(tr_durch)) / P0_3
T_drop = np.array(mp.get_fluxes(tr_drop)) / P0_3
i3 = np.argmin(T_durch)
print(f"auf Resonanz (f = {fs3[i3]:.4f}):  "
      f"T_durch = {T_durch[i3]:.3f},  T_drop = {T_drop[i3]:.3f}")
print(f"daneben (f = {fs3[0]:.4f}):       "
      f"T_durch = {T_durch[0]:.3f},  T_drop = {T_drop[0]:.4f}")
auf Resonanz (f = 0.1494):  T_durch = 0.039,  T_drop = 0.733
daneben (f = 0.1390):       T_durch = 0.966,  T_drop = 0.0273

Auf Resonanz wechselt fast alles die Spur: 73 % der Leistung verlassen den oberen Leiter, im unteren bleiben 4 % — daneben läuft alles ungerührt unten durch. Und die Richtung: Die Bus-Welle läuft nach \(+x\) und prägt dem Ring einen Drehsinn auf (gegen den Uhrzeigersinn); oben angekommen läuft die umlaufende Welle nach \(-x\), also koppelt sie in den oberen Leiter nach links aus — der Drop-Port liegt diagonal gegenüber dem Eingang. Genau so sortieren WDM-Filter im Glasfasernetz einzelne Farbkanäle aus einem Bündel heraus: ein Ring pro Kanal, jeder auf seine Frequenz gestimmt.

Ü 27.4 — Der Preis der Kurve (Übertragen). Miss die Ringmoden für drei Ringgrößen (\(r_{\text{innen}} = 0{,}6\), \(1{,}0\) und \(1{,}5\)) und verfolge jeweils die Mode, die am nächsten an \(f = 0{,}147\) liegt. Vorhersage: Wie ändert sich ihr \(Q\) — linear mit dem Radius oder schneller? Und was sagt das über das Knicken von Glasfasern?

# von oben: ring_moden()
print("Mode nächst f = 0,147 je Ringgröße:")
for r_in in [0.6, 1.0, 1.5]:
    mm = ring_moden(r_in, 0.15, 0.1)
    f_n, q_n = min(mm, key=lambda m: abs(m[0] - 0.147))
    print(f"  r_innen = {r_in}:  f = {f_n:.4f},  Q = {q_n:.0f}")
Mode nächst f = 0,147 je Ringgröße:
  r_innen = 0.6:  f = 0.1463,  Q = 84
  r_innen = 1.0:  f = 0.1473,  Q = 344
  r_innen = 1.5:  f = 0.1420,  Q = 1006

\(Q = 84 \to 344 \to 1006\): grob Verdreifachung je halbe Radiuseinheit — exponentiell, nicht linear. Der Biegeverlust ist ein Tunnelprozess (der evaneszente Saum muss „hinter” den Radius gelangen, ab dem er nicht mehr mitkommt), und Tunnelraten hängen exponentiell von der Barriere ab — Kapitel 17, zum dritten Mal. Für die Glasfaser heißt das: Ein sanfter Bogen (Zentimeter) kostet praktisch nichts, ein scharfer Knick (Millimeter) wirft das Licht fast vollständig hinaus. Deshalb schreiben Faserhersteller Mindest-Biegeradien vor — und deshalb führte in Kapitel 26 nur die Bandlücke, nicht die Totalreflexion, das Licht um die scharfe Ecke.

Das Kleingedruckte

LIGO im Fabry-Pérot-Vokabular. Die 4-km-Arme sind Kavitäten mit Finesse ≈ 450: Das Licht läuft effektiv ~280-mal hin und her, die zirkulierende Leistung erreicht Hunderte Kilowatt, und die Resonanzbedingung verwandelt eine Armlängenänderung von \(10^{-19}\) m in eine messbare Phasendrehung. Dazu kommt „Power Recycling”: Auch der Rest des Interferometers sitzt in einem Resonator, der das ungenutzte Licht zurückwirft — Feldüberhöhung im Quadrat.

Echte Lasersimulation. Unser lineares Gain kennt weder Sättigung noch Spektrum. Meep kann beides: Das MultilevelAtom-Material koppelt die Felder an Besetzungszahlen von Atomniveaus (Ratengleichungen) — damit schwingt eine Simulation wirklich an, sättigt und zeigt Modenkonkurrenz. Der Preis sind mehrere zusätzliche Parameter (Lebensdauern, Dipolstärken, Pumprate) und deutlich längere Läufe; für das Schwellen-Argument dieses Kapitels wäre es Overkill.

Gires-Tournois und der verstimmte Spiegel. Setzt man hinter die Kavität einen perfekten Spiegel, kommt alles Licht zurück (\(|r| = 1\) immer) — aber die Phase dreht sich nahe der Resonanz rasend schnell. Solche Gires-Tournois-Etalons sind reine Phasen-Bauteile, mit denen man Pulse staucht (Dispersionskompensation): Der Resonator als Verzögerungsleitung, Kapitel 16 lässt grüßen.

Frequenzkämme wörtlich. Ein Laser, der viele Längsmoden phasenstarr koppelt (Modenkopplung), sendet einen Kamm aus Tausenden exakt äquidistanten Linien — das Lineal, mit dem man heute optische Frequenzen zählt (Nobelpreis 2005, Hänsch/Hall). Der Zahnabstand ist nichts anderes als unser FSR.