Jekyll2026-10-23T14:54:52+00:00https://jin-castle.github.io/meep-examples/feed.xmlMeep ExamplesMeep(FDTD) 공식 예제와 공개 프로젝트를 직접 실행하며 배우는 시리즈. Korean body, English TL;DR, English code comments.jin-castleMeep Example 09 · Waveguide bend inverse design — 자유 설계 영역과 출력 포트 mode power2026-10-23T00:00:00+00:002026-10-23T00:00:00+00:00https://jin-castle.github.io/meep-examples/bend-inverse1. 먼저 보기: 회색 블록에서 빛은 어디로 갈까?

입력은 왼쪽, 원하는 출력은 위쪽입니다. 가운데 1 × 1 µm 정사각형의 재료만 바꿀 수 있다면, 빛이 90° 꺾이도록 어떤 구조를 만들면 될까요? 05편에서는 반지름 하나를 바꿨고, 이번에는 11 × 11 = 121개 밀도를 바꿉니다.

균일한 밀도 0.5에서 빛이 오른쪽으로 퍼지는 실제 전기장
출발점: 밀도가 모두 0.5입니다. 빛이 오른쪽으로 퍼지고, 위쪽 mode 1 투과율은 0.0154입니다.
MMA 다섯 번째 평가 설계에서 빛이 위쪽 도파관으로 진행하는 실제 전기장
갱신 후: MMA 5회 평가 중 가장 높은 설계입니다. 새 시뮬레이션에서 잰 mode 1 투과율은 0.7801입니다.

이 결과를 읽는 조건. 두 그림은 같은 해상도 10의 실제 Re(Ez) 결과입니다. 같은 설계를 해상도 20으로 다시 재면 투과율은 0.6391입니다. 121개 중 119개가 회색조이고 최적화는 5회 평가뿐이므로, 수렴한 설계나 제작 도면으로 볼 수 없습니다.

어디에 쓰이는가

홈의 고해상도 DFT 예시는 빨강·파랑 파면 + 회색 구조로 표시합니다. 빨강은 음수, 파랑은 양수 Re(Ez)이며 약한 장은 투명하게 합성합니다. 회색은 고정 도파관과 연속 설계 밀도의 표시로, 저장된 실제 유전율 지도는 아닙니다. 원래의 복소장·위상·공통 색상 범위는 보존하고, gradient는 기존 RdBu로 구별합니다. 아래 저해상도 MMA 예제의 원본 그림과는 계산 이력이 다릅니다.

여섯 번의 고해상도 밀도 갱신 후 회색 구조 위의 실제 DFT 파면
해상도 60, 61×61 연속 밀도, 6회 갱신 후의 저장된 정상상태 DFT입니다. 위상 재생은 시간에 따른 광원 켜짐이나 파면 도착을 뜻하지 않습니다.

역설계 bend는 PIC 부품의 면적을 수십 배 줄이는 방법의 첫 예다. 같은 틀이 splitter, crossing, mode converter에 그대로 쓰인다.

응용 이 글의 어떤 것을 쓰는가 그 다음에 필요한 것
초소형 PIC 부품(bend, splitter, crossing, mode converter) 자유 설계 영역 + 출력 모드 목적함수 31·33·34편
foundry 제약 반영(최소 선폭, 이진화) 회색조·선폭 문제의 발견 32편 filter·projection
설계 변수 1개와 121개의 비교 05편 반지름 sweep과 이 글 —

2. 먼저 예측하기: gradient는 완성된 길을 그릴까?

지금 아는 것은 왼쪽에서 들어온 빛을 위로 보내고 싶다는 것뿐입니다. 균일한 출발점에서 계산한 첫 gradient가 무엇을 보여 줄지 골라 보세요.

첫 gradient에서 가장 두드러지는 패턴은?
예측과 실제 결과 비교하기

이 출발점에서는 두 번째에 가깝습니다. 가장 큰 절댓값은 중앙의 음수 −13.4이고, 양수는 두 도파관을 설계 영역 안으로 연장하는 부근에 있습니다. 대각선 모양은 큰 step 뒤 일부 밀도가 0이나 1에 닿으면서 나타납니다. 첫 미분은 현재 설계를 조금 바꿀 방향을 알려 주며, 완성된 형상을 직접 그려 주지는 않습니다.

3. 원리 이해하기: 두 계산에서 한 번의 갱신으로

밀도 ρ는 설계 영역 안의 재료를 정하는 숫자입니다. 0은 SiO₂, 1은 Si, 사이는 두 재료 사이의 보간 값입니다. 왼쪽과 위쪽의 폭 0.5 µm Si 도파관은 고정하고, 정사각형 안의 121개 값만 바꿉니다. 처음에는 모두 0.5이며, 바깥 배경은 공기입니다.

고정된 두 도파관과 중앙의 자유 설계 영역을 설명하는 개념도
왼쪽(+x) 입력과 위쪽(+y) 출력 도파관은 고정하고, 중앙 1 × 1 µm의 11 × 11개 밀도만 바꿉니다. 그림의 격자와 회색 농도는 설명용이며 실제 최적화 결과가 아닙니다.

그림의 입력에서 빛을 보내는 계산이 forward, 출력의 목적함수에서 유도한 source로 설계 영역을 향해 응답을 구하는 별도 계산이 adjoint입니다. 저장한 두 field로 gradient를 구하고, 그 결과를 optimizer에 넘겨 밀도를 갱신합니다.

  1. Forward field: 왼쪽 입력 모드로 빛을 넣고, 위쪽 출력 포트의 mode 1 진폭을 구합니다.
  2. Adjoint field: 목적함수에서 유도한 source로 별도 계산합니다. 이 예제에서는 출력 포트에서 설계 영역 쪽으로 향합니다.
  3. Gradient: 저장한 두 field의 겹침과 재료의 밀도 의존성을 이용해 각 픽셀의 ∂J/∂ρ를 계산합니다.
  4. Geometry update: gradient를 검증한 뒤, optimizer가 0 ≤ ρ ≤ 1 안에서 밀도를 갱신합니다.
실제 초기 signed gradient: 중앙은 강한 음수, 일부 도파관 연결부는 양수
실제로 계산한 초기 11 × 11 gradient입니다. 빨강(양수)은 밀도를 높이는 쪽, 파랑(음수)은 낮추는 쪽이 J를 증가시키는 국소 방향입니다. 양수 49개, 음수 72개입니다.

색을 읽는 기준. 이 그림의 색은 재료 밀도가 아니라 J의 민감도입니다. 밀도를 낮추는 것은 설계 영역 안에서 SiO₂ 쪽으로 옮긴다는 뜻입니다. 검정·회색·흰색으로 그린 밀도 지도와 구별하세요.

목적함수는 출력 mode 1 진폭의 제곱 **J = a_out ²입니다. 최적화 도중의 J는 optimizer의 정규화 관례를 따릅니다. 보고할 투과율은 최종 설계를 **새 시뮬레이션으로 측정하고, 직선 도파관 참조 run의 입력 mode 1 power로 나눈 값입니다.
\[T_{\mathrm{mode1}}= \frac{P_{\mathrm{out,mode1}}\;\text{(fresh run)}}{P_{\mathrm{in,mode1}}\;\text{(reference run)}}\]

계산 범위: 2D Ez(TE), 파장 1.55 µm, Si 굴절률 3.4, SiO₂ 굴절률 1.44, 단일 주파수입니다. 설계 격자 11 × 11과 전자기장을 계산하는 Yee 격자는 서로 다릅니다. 최소 선폭과 이진화 제약은 없습니다.

수식·기호 자세히 보기
목적함수는 출력 포트 monitor에서 잰 mode 1 진폭의 제곱 J = a_out ²이다. 08편과 수학은 같다. forward field E_f는 입력 도파관의 EigenModeSource가 만들고, adjoint field E_a는 출력 포트 monitor 자리에서 거꾸로 쏜 EigenModeSource가 만든다. gradient는 두 field의 겹침에 재료의 밀도 의존성과 정규화 계수를 반영해 구한다. 아래 비례식은 그 관계를 개념적으로 나타낸 것이다. 08편에서 adjoint가 위쪽 평면파 monitor에서 내려왔다면, 여기서는 출력 도파관을 타고 설계 영역으로 내려온다. 목적함수가 바뀌면 adjoint source의 위치와 모양이 바뀐다.
\[J=\lvert a_{\mathrm{out}}\rvert^{2},\qquad \frac{\partial J}{\partial \rho_i}\;\propto\;\mathrm{Re}\big(E_f\cdot E_a\big)\Big|_{\text{pixel } i},\qquad T_{\mathrm{mode1}}=\frac{\lvert a_{\mathrm{out}}\rvert^{2}_{\text{fresh run}}}{P_{\mathrm{in}}}\]

보고하는 투과율 T_mode1의 분모 P_in은 직선 도파관만 있는 참조 run에서 입력면(x = −1 µm)의 mode 1 power다. 분자는 최종 설계를 새 Simulation에 넣고 get_eigenmode_coefficients로 다시 잰 값이다. optimizer가 돌려주는 J는 이 분모와 같은 잣대로 정규화되어 있지 않다. 실제로 J/P_in은 1.056이 나온다.

기호 뜻 코드 변수
ρ (121개) 설계 밀도. 0 SiO2, 1 Si, 사이는 회색조 x_start, x_optimized
J 출력 포트 mode 1 power |a_out|² (optimizer 단위) fom(x)
g adjoint gradient ∂J/∂ρ g_start
v, s gate 방향(g/|g|), FD step v, steps
α 손 step 크기 one_step
P_in 입력면 mode 1 power (참조 run) input_power
T_mode1, T_total 새 run의 mode 1 power / P_in, 전체 flux / P_in report

가정과 유효 범위: 2D Ez(TE), 굴절률 Si 3.4 / SiO2 1.44, 폭 0.5 µm, 해상도 10(픽셀 100 nm), 단일 주파수. 설계 격자 11 × 11은 Yee 격자와 별개다. 제작 제약(최소 선폭, 이진화)은 없다.

4. 직접 실행하기: step 크기 하나만 비교하기

먼저 전체 스크립트와 공통 helper를 같은 폴더에 두세요. bend_inverse.py와 blogfig.py가 필요합니다. Meep 1.33.0, NLopt, autograd가 준비된 환경에서 원본을 한 번 실행합니다. 기록된 실행 시간은 단일 코어 약 29초입니다.

python bend_inverse.py

이번에 볼 출력은 one manual step: 한 줄입니다. 원본은 같은 출발점과 같은 정규화 gradient 방향에서 α = 0.2, 1, 3, 8을 비교합니다. 각 설계는 앞선 결과에 이어서 움직인 것이 아니라, 모두 균일한 0.5에서 한 번씩 이동한 결과입니다.

# 원본 전체 코드에서 발췌: 이 조각만 단독 실행하지 않습니다.
x_try = np.clip(x_start + alpha * v, 0, 1)

한 가지 실험: 원본의 for alpha in (0.2, 1.0, 3.0, 8.0):에서 마지막 값만 4.0으로 바꿔 다시 실행하세요. α = 4와 8에서 J와 밀도 포화가 어떻게 달라질지 먼저 적고, 출력과 06_step_mma.png로 확인합니다. 다른 파라미터와 MMA 평가 횟수는 그대로 둡니다.

실행 전 확인: gradient gate가 PASS인지 먼저 봅니다. 이 예제는 세 유한차분 step 모두 상대오차가 0.01% 이내였습니다. gate가 HOLD이면 optimizer 결과 해석을 멈추고 원인을 확인하세요. 입력 mode 1 비율이 0.95 아래라면 source부터 점검합니다.

시뮬레이션 설계도·파라미터·source 검증
6×5 마이크로미터 계산 셀의 source와 입출력 monitor 배치
6 × 5 µm 셀과 PML 1 µm입니다. Source는 x = −1.5 µm, 입력 monitor는 x = −1 µm, 출력 monitor는 y = 1 µm에 있습니다.
파라미터 값 왜 이 값인가 바꾸면
셀, 해상도 6 × 5 µm, res 10 강의 week 10과 같다. 한 run이 2~3 s res 20이면 결과 해석의 해상도 표처럼 값이 바뀐다
설계 영역 1 × 1 µm, 11 × 11 도파관 폭의 2배. 변수 121개 1.5 × 1.5면 변수 256개, 시간도 비례
초기값 균일 0.5 내부점이라 gate를 바로 잴 수 있고 방향 편향이 없다 0/1 초기값이면 08편처럼 clip 처리 필요
source mode 1, fwidth 0.12 fcen 좁은 대역. 단일 주파수 목적함수에 맞춘다 넓히면 펄스가 짧아져 GIF에 좋지만 forward run은 그대로
monitor 출력 y = 1, 폭 2 µm 설계 영역에서 0.5 µm 떨어진 곳 설계 영역에 붙이면 근접장이 mode 분해에 섞인다
gate steps 2e-3, 5e-3, 1e-2 08편과 같다 —
손 step α 0.2, 1, 3, 8 08편(0.05~2)보다 넓다. 포화를 보기 위해 —
maxeval 5 수업용 smoke test 수렴을 보려면 수십 회 + 이진화
가우스 source의 시간 파형과 주파수 스펙트럼
fwidth = 0.12 fcen인 source입니다. 펄스 폭은 12.9, 정점은 t0 = 64.6 µm/c이며, 1550 nm에서 ±50 nm 밖의 power는 1% 아래입니다.
직선 도파관 참조 실행에서 측정한 입력 모드
입력 mode 1 power / 전체 flux = 1.0043입니다. 분자는 전방 mode 1, 분모는 전방에서 후방을 뺀 순 flux여서 1을 조금 넘을 수 있습니다.

강의 노트북과의 차이: 파라미터와 수치(mode 1 비율 1.0043, gate 0.0000/0.0000/0.0001, 손 step 16.7/118.9/176.2/235.5, MMA 4.31 → 222.4, 검증 0.0154 → 0.7801)는 강의 week 10과 같다. 강의는 Meep 1.34, 여기는 1.33인데 소수 넷째 자리까지 같다. 이 글이 더한 것은 해상도 20에서의 재측정(결과 해석 수렴성)과 GIF 두 개, 단계 번호가 붙은 설계도다.

코드 7단계 해설: 각 줄의 역할과 흔한 함정

읽는 순서: 단위·파라미터 → 재료·구조 → source → Simulation·경계 → monitor → 실행·종료 → 후처리. 08편과 같은 구조이고, 달라지는 줄은 ⑤의 목적함수와 ⑦의 정규화뿐이다.

① 단위와 파라미터 — 어떤 숫자를 고정하는가

wl, fcen, fwidth = 1.55, 1 / 1.55, 0.12 / 1.55
Si, SiO2 = mp.Medium(index=3.4), mp.Medium(index=1.44)
RES, SX, SY, DPML, W = 10, 6.0, 5.0, 1.0, 0.5
SRC_X, MON_IN_X, MON_OUT_Y = -1.5, -1.0, 1.0        # source, input monitor, objective monitor
D, NX, NY = 1.0, 11, 11                                # design square and its grid (121 densities)
x_start = 0.5 * np.ones(NX * NY)                        # uniform grey: interior point, no bias
  • 무엇: 셀, 도파관, 설계 격자, 세 평면(source, 입력 monitor, 출력 monitor)의 위치.
  • 왜: 입력 monitor는 source와 설계 영역 사이에 둔다. 참조 run에서 여기서 잰 mode 1 power가 모든 투과율의 분모다. 출력 monitor는 설계 영역에서 0.5 µm 띄운다.
  • 틀리면: 설계 격자 11 × 11을 Yee 격자(res 10이면 1 µm에 10칸)와 혼동하면 “픽셀 하나 = 격자 하나”로 착각한다. MaterialGrid는 설계 격자를 Yee 격자에 보간한다.

② 재료와 구조 — 무엇이 어디에 있는가

def waveguide_blocks():
    return [mp.Block(center=mp.Vector3(-SX / 4, 0), size=mp.Vector3(SX / 2, W), material=Si),    # input, from -x
            mp.Block(center=mp.Vector3(0, SY / 4), size=mp.Vector3(W, SY / 2), material=Si)]     # output, to +y

design_variables = mp.MaterialGrid(mp.Vector3(NX, NY), SiO2, Si, grid_type="U_MEAN", do_averaging=False)   # contract 1
design_region = mpa.DesignRegion(design_variables, volume=mp.Volume(center=mp.Vector3(), size=mp.Vector3(D, D)))
geometry = waveguide_blocks() + [mp.Block(center=design_region.center, size=design_region.size, material=design_variables)]
  • 무엇: 고정된 Si 도파관 두 개와, 원점의 정사각형 MaterialGrid. 최적화는 정사각형 안만 바꾼다.
  • 왜: 두 도파관이 설계 영역의 왼쪽 변과 위쪽 변에 닿는다. 설계 영역이 둘을 어떻게 이을지는 gradient가 정한다.
  • 틀리면: 도파관 블록이 설계 영역과 겹치면 겹친 곳의 유전율은 나중 객체가 이긴다. 설계 영역을 마지막에 두어야 밀도가 반영된다.

③ Source — 빛을 어떻게 넣는가

sources = [mp.EigenModeSource(mp.GaussianSource(fcen, fwidth=fwidth), eig_band=1, direction=mp.NO_DIRECTION,
                              eig_kpoint=mp.Vector3(1, 0, 0), size=mp.Vector3(0, 2), center=mp.Vector3(SRC_X, 0))]
adjoint_sources = opt.adjoint_sources[0]      # one EigenModeSource at the OUTPUT monitor, made by opt
  • 무엇: 04편과 같은 EigenModeSource. adjoint source는 OptimizationProblem이 출력 monitor 자리에 만든다.
  • 왜: 목적함수가 mode 1 진폭이므로 adjoint source도 mode 1 모양이다. 08편에서는 평면파였다.
  • 틀리면: direction=mp.NO_DIRECTION에 eig_kpoint를 빼면 모드 방향이 정해지지 않는다. 참조 run의 mode 1 비율이 1에서 멀면 여기부터 의심한다.

④ Simulation과 경계 — 계산 상자와 PML

common = dict(resolution=RES, cell_size=mp.Vector3(SX, SY), boundary_layers=[mp.PML(DPML)], sources=sources, eps_averaging=False)
sim = mp.Simulation(geometry=geometry, **common)
stop_cond = mp.stop_when_fields_decayed(30, mp.Ez, mp.Vector3(0, MON_OUT_Y), 1e-5)
  • 무엇: 네 변 모두 PML 1 µm. 종료 감시점은 출력 monitor 중앙.
  • 왜: forward, adjoint, FD, 검증, 해상도 확인이 모두 같은 common을 쓴다. 해상도만 바꿔 끼운다.
  • 틀리면: eps_averaging을 기본값으로 두면 계약 1이 깨진다. 설계 영역 안에서는 do_averaging=False, 밖에서는 eps_averaging=False가 각각 담당한다.

⑤ Monitor — 목적함수

out_mode = mpa.EigenmodeCoefficient(sim, mp.Volume(center=mp.Vector3(0, MON_OUT_Y), size=mp.Vector3(2, 0)), mode=1)
opt = mpa.OptimizationProblem(simulation=sim, objective_functions=lambda a: npa.abs(a) ** 2,
                              objective_arguments=[out_mode], design_regions=[design_region], fcen=fcen, df=0, nf=1)
  • 무엇: 출력 monitor 선 위의 mode 1 진폭 a_out을 인자로, a_out ²를 목적함수로.
  • 왜: 08편의 kpoint_func와 eig_vol이 없다. 도파관 모드는 monitor 폭 전체에서 풀면 되고 방향은 monitor의 법선이다. 바뀐 줄은 이 두 줄뿐이다.
  • 틀리면: monitor 폭 2 µm가 도파관(0.5 µm)보다 충분히 넓어야 모드 꼬리를 담는다. 폭을 0.5로 줄이면 a_out이 작아지고 gradient도 그만큼 틀어진다.

⑥ 실행 — forward, adjoint, gate, 한 걸음, MMA

f, dJ = opt([x], need_gradient=True)                   # forward + adjoint: J and dJ/drho for all 121 pixels

v = g_start / np.linalg.norm(g_start)                   # gate: gradient direction, x_start is already interior
fd = (fom(x_start + s * v) - fom(x_start - s * v)) / (2 * s)
ok = abs(g_start @ v - fd) / abs(fd) <= 0.20

x_try = np.clip(x_start + alpha * v, 0, 1)              # one step by hand, alpha in (0.2, 1, 3, 8)

solver = nlopt.opt(nlopt.LD_MMA, NX * NY); solver.set_lower_bounds(0); solver.set_upper_bounds(1)
solver.set_max_objective(nlopt_objective); solver.set_maxeval(5)
x_optimized = design_history[int(np.argmax(history))]  # keep the best evaluated design
  • 무엇: 08편과 같은 순서. gate, 손 step, MMA 5회, 최고 평가 보관.
  • 왜: 초기값이 0.5 균일이라 clip 없이 바로 gate를 잰다. 08편에서 0/1 baseline을 0.02~0.98로 밀어 넣던 단계가 빠진다.
  • 틀리면: solver.optimize가 돌려주는 x는 마지막 평가가 아니라 MMA 내부 상태다. 보고할 설계는 history에서 고른다.

⑦ 후처리 — 계약 4, 별도 검증과 정규화

def modal_power(weights, res=RES):
    s = mp.Simulation(geometry=geometry_with(weights), **dict(common, resolution=res))      # a NEW simulation
    mon = s.add_mode_monitor(fcen, 0, 1, mp.ModeRegion(center=mp.Vector3(0, MON_OUT_Y), size=mp.Vector3(2, 0)))
    s.run(until_after_sources=stop_cond)
    mode1 = abs(s.get_eigenmode_coefficients(mon, [1], direction=mp.Y).alpha[0, 0, 0]) ** 2
    return mode1, mp.get_fluxes(mon)[0]

T_mode1 = mode1 / input_power          # input_power: mode-1 power at x = -1 um in the straight-waveguide run
  • 무엇: 최종 설계를 새 Simulation에 넣고 출력 포트의 mode 1 power와 전체 flux를 다시 잰 뒤 P_in으로 나눈다. 같은 함수에 res = 20을 넣어 한 번 더 잰다.
  • 왜: optimizer 내부 J를 P_in으로 나누면 1.056이 나온다. 단위가 다른 숫자다. 투과율이라 부를 수 있는 값은 이 함수가 돌려주는 것뿐이다.
  • 틀리면: res 20 검사에서 분모도 res 20의 참조 run으로 다시 재야 한다. 분자만 바꾸면 해상도 차이가 아니라 정규화 차이를 보게 된다.
함정: mpa.EigenmodeCoefficient의 a ²와 get_eigenmode_coefficients의 α ²는 같은 물리량이지만 정규화 관례가 다르다. 둘을 섞어 비율을 만들면 1이 넘는 투과율이 나온다. 분자와 분모를 같은 함수로 재는 것이 계약 4의 실질이다.

5. 결과 해석하기: 좋아진 숫자가 무엇을 뜻할까?

이 예제에서는 α가 8까지 커져도 J가 올랐습니다. 그렇다고 큰 step이 언제나 유리한 것은 아닙니다. 08편은 큰 step에서 값이 떨어졌고, 이 예제의 MMA도 4.31 → 180.7 → 4.5 → 106.2 → 222.4처럼 오르내렸습니다. 그래서 평가한 설계 중 가장 높은 J를 낸 5회차를 보관합니다.

확인할 값 출발점 보관한 설계
새 run의 mode 1 투과율 0.0154 0.7801
새 run의 전체 flux / 입력 mode 1 power 0.1165 0.8040

두 열은 같은 참조 입력 power로 정규화했습니다. 최종 T_total과 T_mode1의 차이 약 0.024는 출력면을 지났지만 mode 1로 잡히지 않은 몫입니다.

J = 222.4를 투과율로 읽지 않기. 이를 입력 power 210.6으로 나누면 1.056이 됩니다. 두 수의 정규화 관례가 다르기 때문입니다. 분자와 분모를 같은 함수로 다시 측정한 투과율이 0.7801입니다.

이 설계를 얼마나 믿을 수 있을까?

gradient gate 통과는 현재 계산 설정에서 미분이 맞는지 확인합니다. 최적화 수렴, 해상도 수렴, 제작 가능성까지 보장하지는 않습니다.

검사 이번 결과 의미
Gradient gate 세 step 모두 PASS, 오차 0.01% 이내 유한차분과 adjoint가 일치
같은 121개 밀도, 해상도 10 → 20 T_mode1 0.7801 → 0.6391 해상도 수렴이 확인되지 않음
밀도와 평가 횟수 회색조 119/121개, MMA 5회 이진 재료 설계나 수렴한 최적해가 아님

해상도 검사에서는 설계 밀도를 그대로 두고 Yee 격자를 세분화하며, 분모인 참조 입력 power도 새 해상도에서 다시 잽니다. 이번 결과는 adjoint 절차를 배우는 짧은 시연입니다. 다른 파장·편광·3D 성능이나 제조 성능은 이 수치에서 알 수 없습니다.

시간에 따른 빛과 설계의 변화

갱신한 설계에서 짧은 펄스가 출력 도파관으로 진행하는 애니메이션
fwidth = 0.3 fcen의 짧은 펄스가 source에서 출력 monitor로 진행합니다. 정지하면 별도 검증의 실제 field 그림을 보여줍니다.
균일 출발점에서 MMA 평가 1~5와 최종 설계로 변하는 애니메이션
균일 출발점 → MMA 평가 1~5 → 보관한 5회차 순으로 바뀝니다. 정지하면 같은 실제 평가 이력의 전체 그림을 보여줍니다.
원본 결과 그림·수치표 자세히 보기
균일 및 랜덤 출발점의 정방향 field와 균일 출발점의 수반 field
위는 균일 출발점(J = 4.31), 아래는 랜덤 출발점(J = 12.23)의 forward field입니다. 오른쪽 열은 출력에서 시작한 균일 출발점의 adjoint field입니다.
균일한 밀도 0.5에서 계산한 signed gradient와 gradient 절댓값
초기 gradient의 가장 큰 절댓값은 중앙의 음수 −13.4입니다. 양수 49개, 음수 72개이며, 양수는 주로 두 도파관을 설계 영역 안으로 연장하는 부근에 있습니다.
세 step에서 유한차분과 수반 방향미분을 비교한 gradient gate
세 step의 유한차분은 38.240, 38.241, 38.244이고 adjoint는 38.240입니다. 세 번 모두 gate를 통과했습니다.
step FD adjoint g·v 상대오차
2e-3 38.2396 38.2395 0.0000
5e-3 38.2405 38.2395 0.0000
1e-2 38.2436 38.2395 0.0001
한 번의 gradient step 크기별 설계와 MMA 다섯 번의 평가 이력
위는 같은 출발점에서 α만 달리한 한 걸음, 아래는 MMA의 실제 평가 이력입니다. 5회차 J = 222.4를 보관했으며 119/121개 픽셀이 회색조입니다.
α J J / J_start
0.2 16.66 3.9
1.0 118.92 27.6
3.0 176.24 40.9
8.0 235.54 54.7

08편에서는 α = 2에서 목적함수가 떨어졌다. 여기서는 α = 8까지 오른다. 출발점이 균일 0.5라 각 픽셀은 “올릴지 내릴지”만 정해지면 되고, 끝까지 밀어 clip되어도 방향이 맞으면 J는 오른다. 08편의 출발점은 이미 괜찮은 설계였고 거기서 멀리 가면 구조가 망가졌다. 좋은 step size는 문제마다 다르다. optimizer가 step을 스스로 조절해야 하는 이유다.

새 시뮬레이션에서 다시 측정한 투과율과 출발점 및 갱신 후 전기장
새 시뮬레이션의 정규화 투과율과 Re(Ez)입니다. 갱신한 설계에서는 빛이 위로 꺾여 출력 도파관을 탑니다.
설계 mode 1 power 전체 flux T_mode1 T_total
균일 0.5 출발점 3.247 24.546 0.0154 0.1165
최적화 (MMA eval 5) 164.29 169.33 0.7801 0.8040

T_total과 T_mode1의 차이(0.024)는 출력면을 지났지만 mode 1이 아닌 몫이다. 05편의 진단식과 같은 구분이다. optimizer 내부 J = 222.4를 P_in = 210.6으로 나누면 1.056이다. 그 숫자는 투과율이 아니다.

예측과 비교

물리량 내 예측 (처음의 예측) 시뮬레이션 판정
입력면 mode 1 비율 0.98~1.02 1.0043 ✅
출발점 T_mode1 몇 % 0.0154 ✅
gradient 패턴 대각선 띠가 양수 중앙 음수, 두 도파관 연장선이 양수. 대각선은 큰 step 뒤에야 나타남 ❌
gate 상대오차 1% 안 0.00%, 0.00%, 0.01% ✅
손 step α 오르다 꺾임 α = 8까지 계속 상승 ❌
MMA 5회 뒤 T_mode1 0.5~0.7 0.780 ❌ (예측보다 높음)
해상도 20에서 같은 설계 몇 % 차이 0.780 → 0.639 ❌
회색조 픽셀 절반 이상 119 / 121 ✅

예측이 네 개 틀렸고, 틀린 것이 이 글의 내용이다. 첫째, 날것 gradient는 거울을 그리지 않는다. 첫 미분이 말하는 것은 “중앙의 밀도를 낮추고 두 도파관 연결부의 밀도를 높여라”이고, 대각선은 여러 픽셀이 포화한 뒤에 나타나는 구조다. 둘째, step size의 직관은 문제를 넘어 옮겨지지 않는다. 셋째, 다섯 번으로 0.78까지 간 것은 설계 자유도가 큰 덕이지 설계가 좋아서가 아니다. 넷째, 해상도 20에서 0.64로 떨어진 것은 이 설계가 res 10의 격자에 맞춰진 설계라는 뜻이다.

수렴성

변수 값 T_mode1 T_total 비고
해상도 10 0.7801 0.8040 최적화에 쓴 해상도
해상도 20 0.6391 0.6870 같은 11 × 11 밀도, 분모도 res 20 참조 run
gate step 2e-3 / 5e-3 / 1e-2 FD 38.240 / 38.241 / 38.244 — 세 step 모두 adjoint 38.240과 0.01% 안

해상도 10에서 Si 안의 파장은 456 nm이고 격자 간격은 100 nm다. 파장당 4.5칸은 Meep 문서의 권장(8칸 이상)에 못 미친다. 회색조 픽셀이 119개라 유전율이 매끄럽게 변하는 설계인데, 그 보간이 Yee 격자에 어떻게 얹히는지가 해상도에 따라 다르다. res 20에서 다시 최적화하면 다른 설계가 나온다. 별도로 표시한 해상도 검사 외의 최적화 결과는 res 10에서의 값이다.

주장할 수 있는 것 / 없는 것

  • 할 수 있는 것: 이 셀, 해상도 10, 단일 주파수에서 adjoint gradient는 유한차분과 0.01% 안에서 같다. 균일 0.5에서 다섯 번의 MMA 평가로 출력 mode 1 투과율이 0.015에서 0.780으로 올랐고, 그 값은 별도 run으로 재확인됐다. 08편의 절차는 목적함수를 바꿔도 그대로 쓰인다.
  • 할 수 없는 것: “0.78짜리 bend를 설계했다”. 121개 중 119개가 회색조라 물리적 재료가 아니다. 해상도 20에서 0.64다. maxeval 5는 수렴이 아니다. 최소 선폭 제약이 없어 이진화하면 값이 달라진다. 다른 파장, 다른 편광, 3D에서의 값.
문제가 생겼을 때: 증상과 점검 위치
증상 원인 고치는 법
투과율이 1을 넘음 optimizer 내부 J를 P_in으로 나눔 분자와 분모를 같은 함수(get_eigenmode_coefficients)로
mode 1 비율이 0.9 아래 source 폭이 모드 꼬리를 못 담거나 eig_kpoint 누락 참조 run의 field를 먼저 보고 source 폭 2 µm 확인
gate HOLD 초기값이 0/1 경계이거나 랜덤 방향 내부점, gradient 방향(08편 §6)
손 step에서 값이 떨어짐 문제에 따라 정상 꺾이는 α를 기록하고 optimizer에 맡김
MMA가 중간에 추락 신뢰영역 과대 정상 동작. 최고 평가를 보관
해상도를 올리니 값이 다름 설계가 격자에 맞춰짐 목표 해상도에서 최적화하거나 필터로 선폭 제한
회색조 설계를 소자로 해석 이진화·선폭 제약 없음 필터·투영·β 스케줄(공식 adjoint 예제 02 이후)

6. 확인하기: 두 가지를 설명할 수 있나요?

1. Forward와 adjoint는 각각 어디에서 시작하며, gradient는 무엇을 바꾸라고 하나요?

Forward는 왼쪽 입력 도파관의 mode 1 source에서 시작합니다. Adjoint는 출력 mode 1 목적함수에서 유도되어 위쪽 출력 포트에 생긴 source로 별도 계산합니다. 두 계산으로 얻은 gradient는 설계 영역의 121개 밀도를 현재 상태에서 어느 방향으로 바꾸면 J가 늘어나는지 알려 줍니다. 첫 gradient 자체가 최종 도파관 모양은 아닙니다.

2. J = 222.4이고 투과율이 0.7801인데, 왜 완성된 소자라고 할 수 없나요?

J는 optimizer 내부 정규화 값이며 투과율은 새 run과 참조 run에서 다시 측정한 전력의 비입니다. 투과율도 해상도를 20으로 올리면 0.6391로 달라집니다. 설계는 119개 회색조 픽셀을 포함하고 평가도 5회뿐입니다. 해상도·최적화 수렴과 최소 선폭·이진화 검증이 더 필요합니다.

7. 참고 자료와 전체 코드

English summary
  • What: post 05 steered a 90° bend with one number, the radius. Here the corner is a 1 × 1 µm square opened as a free design region of 11 × 11 densities (SiO2 to Si), and the adjoint gradient fills it. The contract is the one from post 08; only the objective changes, from a diffraction order to the mode-1 power at the output port.
  • Result: the source puts 100.4 % of its flux into mode 1. The gradient passes the gate with 0.00 %, 0.00 %, 0.01 % error. Unlike post 08, one hand-made step keeps rising as α grows (3.9×, 28×, 41×, 55×) because pixels saturate at 0/1. Five MMA evaluations lift the internal objective 52×. Measured again in a fresh simulation and normalized to the input mode-1 power, the bend transmission goes from 0.015 to 0.780 (total flux through the port: 0.117 to 0.804). At twice the resolution the same design gives 0.639.
  • Takeaway: the four steps transfer unchanged when the objective changes. What does not transfer is intuition about step size: whether a gradient step overshoots depends on the problem. The optimizer’s internal number is not a transmission (it even exceeds the input power), 119 of 121 pixels are still grey, and the design is not converged in resolution. This is a smoke test, not a device.
  • Code: full script at the bottom, ~29 s on one core.
처음 세웠던 예측과 추가 실험 아이디어

결과 보기 전에 맞춰보기

물리량 내 예측 근거
입력면 mode 1 비율 0.98~1.02 04편에서 EigenModeSource는 단일 모드를 넣었다
균일 0.5 출발점의 T_mode1 몇 % 회색 블록은 도파관이 아니다. 빛은 직진해서 새어 나간다
gradient 패턴 입력과 출력을 잇는 대각선 띠가 양수 45° 거울이 가장 단순한 bend다
gate 상대오차 1% 안 08편 0.7%
손 step α 오르다 꺾임 08편과 같은 선형 근사의 한계
MMA 5회 뒤 T_mode1 0.5~0.7 자유도 121, 05편 sharp bend 0.20보다는 높을 것
해상도 20에서 같은 설계 몇 % 차이 설계는 격자에 고정됐으니 유전율 분포는 같다
회색조 픽셀 절반 이상 5회로는 포화하지 않는다

판정 기준: gate 상대오차 > 20%면 HOLD. mode 1 비율이 0.95 아래면 source부터 다시. T_mode1 > T_total이면 분해 오류.

바꿀 것 예상 변화 확인할 수치
설계 영역 1 × 1 → 1.5 × 1.5 µm 변수 256개, 시간 2배 T_mode1, 회색조 수
초기값을 05편의 사분원 bend 모양으로 출발점 T가 0.9 근처, gradient는 작음 J_start, gate, 5회 뒤 변화
maxeval 5 → 30 투과율이 어디서 정체하는지 history, 회색조 수
res 20에서 처음부터 최적화 다른 설계, res 10과 비교 두 해상도의 T_mode1
목적함수를 두 주파수 평균으로 (nf=2) 대역폭 대 피크 trade-off 각 주파수의 T_mode1

전체 Python 코드

code/bend_inverse.py 전체 (클릭하여 펼치기) 
"""Meep Example 09 - Waveguide bend inverse design (adjoint), with the same four-step contract as post 08.

Post 05 turned a 90-degree bend with ONE design variable (the radius). Here the corner is a 1 x 1 um square
opened as a free design region (11 x 11 densities, SiO2..Si) and the adjoint gradient fills it. Only the
objective changes: not a diffraction order but the guided mode-1 power at the output port.
  1. differentiability: eps_averaging=False, MaterialGrid do_averaging=False
  2. gradient gate: adjoint gradient vs centred finite differences along the gradient direction (interior point)
  3. a short MMA run (maxeval 5): a smoke test, not a converged design
  4. verification in a FRESH simulation with get_eigenmode_coefficients, normalized by the input mode-1 power
Plus: source check on a straight waveguide, forward field of uniform and random starts, adjoint field,
raw gradient, one manual step, a resolution check of the final design, two GIFs.

Run:  python bend_inverse.py      (~1 min on one core)
Out:  00_source.png, 01_layout.png, 02_source_check.png, 03_fields.png, 04_gradient.png, 05_gate.png,
      06_step_mma.png, 07_verify.png, 08_anim_optimized.gif, 09_anim_design.gif, result.json  (-> ../assets/09/)
"""
import json
import os
import sys
import time

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib import animation
import meep as mp
import meep.adjoint as mpa
import nlopt
from autograd import numpy as npa

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from blogfig import Label, animate_fields, annotated_layout, record_frames, source_figure   # noqa: E402

HERE = os.path.dirname(os.path.abspath(__file__))
OUT = os.path.join(HERE, "..", "assets", "09")
os.makedirs(OUT, exist_ok=True)
t_all = time.time()
np.random.seed(20260820)

# ---------------------------------------------------------------- (1) units & parameters (course week 10)
wl = 1.55
fcen = 1 / wl
fwidth = 0.12 * fcen
Si, SiO2 = mp.Medium(index=3.4), mp.Medium(index=1.44)
RES = 10
SX, SY = 6.0, 5.0
DPML = 1.0
W = 0.5                                   # waveguide width
SRC_X, SRC_SIZE = -1.5, 2.0               # EigenModeSource on the input waveguide
MON_IN_X = -1.0                           # input-power monitor (between source and design region)
MON_OUT_Y = 1.0                           # objective monitor on the output waveguide
D = 1.0                                   # design region side
NX = NY = 11                              # design grid: 11 x 11 = 121 densities
EXTENT = [-0.5 * SX, 0.5 * SX, -0.5 * SY, 0.5 * SY]
DEXT = [-0.5 * D, 0.5 * D, -0.5 * D, 0.5 * D]

sources = [mp.EigenModeSource(mp.GaussianSource(fcen, fwidth=fwidth), eig_band=1, direction=mp.NO_DIRECTION,
                              eig_kpoint=mp.Vector3(1, 0, 0), size=mp.Vector3(0, SRC_SIZE), center=mp.Vector3(SRC_X, 0))]
common = dict(resolution=RES, cell_size=mp.Vector3(SX, SY), boundary_layers=[mp.PML(DPML)], sources=sources, eps_averaging=False)
stop_cond = mp.stop_when_fields_decayed(30, mp.Ez, mp.Vector3(0, MON_OUT_Y), 1e-5)


# ---------------------------------------------------------------- (2) geometry: input (-x) and output (+y) waveguides + design square
def waveguide_blocks():
    return [mp.Block(center=mp.Vector3(-SX / 4, 0), size=mp.Vector3(SX / 2, W), material=Si),
            mp.Block(center=mp.Vector3(0, SY / 4), size=mp.Vector3(W, SY / 2), material=Si)]


def geometry_with(weights):
    grid = mp.MaterialGrid(mp.Vector3(NX, NY), SiO2, Si, weights=np.asarray(weights).reshape(NX, NY), grid_type="U_MEAN", do_averaging=False)
    return waveguide_blocks() + [mp.Block(center=mp.Vector3(), size=mp.Vector3(D, D), material=grid)]


design_variables = mp.MaterialGrid(mp.Vector3(NX, NY), SiO2, Si, grid_type="U_MEAN", do_averaging=False)     # contract 1
design_region = mpa.DesignRegion(design_variables, volume=mp.Volume(center=mp.Vector3(), size=mp.Vector3(D, D)))
geometry = waveguide_blocks() + [mp.Block(center=design_region.center, size=design_region.size, material=design_variables)]

# ---------------------------------------------------------------- (4) simulation + (5) objective: output-port mode-1 power
sim = mp.Simulation(geometry=geometry, **common)
out_mode = mpa.EigenmodeCoefficient(sim, mp.Volume(center=mp.Vector3(0, MON_OUT_Y), size=mp.Vector3(2, 0)), mode=1)
opt = mpa.OptimizationProblem(simulation=sim, objective_functions=lambda a: npa.abs(a) ** 2, objective_arguments=[out_mode],
                              design_regions=[design_region], fcen=fcen, df=0, nf=1)
x_start = 0.5 * np.ones(NX * NY)          # uniform grey: an interior point, differentiable, no bias
opt.update_design([x_start])
# a throw-away copy only for the layout figure: plot2D draws flux monitors, mpa objectives it does not
sim_plot = mp.Simulation(geometry=geometry_with(x_start), **common)
sim_plot.add_flux(fcen, 0, 1, mp.FluxRegion(center=mp.Vector3(0, MON_OUT_Y), size=mp.Vector3(2, 0)))
sim_plot.add_flux(fcen, 0, 1, mp.FluxRegion(center=mp.Vector3(MON_IN_X, 0), size=mp.Vector3(0, 2)))
annotated_layout(
    sim_plot, os.path.join(OUT, "01_layout.png"), dpml=DPML, figsize=(7.4, 6.0), axis_step=1.0,
    title="bend as a free design region: input -x, output +y, 1 x 1 um square of 11 x 11 densities",
    params_text=f"wl={wl} res={RES}\ncell {SX}x{SY}, w={W}\nNx=Ny={NX} (121 vars)",
    params_xy=(-2.9, 2.3), pml_xy=(-2.5, -0.5 * SY + 0.5 * DPML), decay_point=(0, MON_OUT_Y), decay_text_xy=(0.9, 1.75),
    labels=[Label("design region: MaterialGrid, start = uniform 0.5", (-0.5, -0.5), (-2.9, -1.3), step=2, color="black"),
            Label("EigenModeSource, mode 1 -> +x", (SRC_X, 0.6), (-2.9, 1.3), step=3, color="red"),
            Label("objective: |a_out|^2 on this line", (0.8, MON_OUT_Y), (0.9, 0.5), step=5, color="blue"),
            Label("input monitor (normalization)", (MON_IN_X, -0.8), (-0.2, -2.0), step=5, color="blue")])
source_figure(fcen, fwidth, os.path.join(OUT, "00_source.png"), wl_scale=1000.0, wl_unit="nm", time_unit="um/c")


def run_dft_field(src_list, geometry_list):
    s = mp.Simulation(geometry=geometry_list, **dict(common, sources=src_list))
    dft = s.add_dft_fields([mp.Ez], fcen, 0, 1, center=mp.Vector3(), size=mp.Vector3(SX, SY))
    s.run(until_after_sources=stop_cond)
    field = s.get_dft_array(dft, mp.Ez, 0); eps = s.get_epsilon(); s.reset_meep()
    return field, eps


def contour(a, eps):
    xs = np.linspace(EXTENT[0], EXTENT[1], eps.shape[0]); ys = np.linspace(EXTENT[2], EXTENT[3], eps.shape[1])
    a.contour(xs, ys, eps.T, levels=[0.5 * (1.44 ** 2 + 3.4 ** 2)], colors="w", linewidths=0.6, alpha=0.9)


def show_design(a, weights, title):
    im = a.imshow(np.asarray(weights).reshape(NX, NY).T, origin="lower", extent=DEXT, cmap="gray_r", vmin=0, vmax=1, aspect="equal")
    a.set_title(title, fontsize=8); a.set_xlabel("x [um]")
    return im


# ---------------------------------------------------------------- source check: straight waveguide, mode-1 share at the input monitor
straight = [mp.Block(center=mp.Vector3(), size=mp.Vector3(mp.inf, W), material=Si)]
field_src, eps_src = run_dft_field(sources, straight)
s_in = mp.Simulation(geometry=straight, **common)
mon_in = s_in.add_mode_monitor(fcen, 0, 1, mp.ModeRegion(center=mp.Vector3(MON_IN_X, 0), size=mp.Vector3(0, 2)))
s_in.run(until_after_sources=mp.stop_when_fields_decayed(30, mp.Ez, mp.Vector3(MON_IN_X, 0), 1e-5))
total_in = float(mp.get_fluxes(mon_in)[0])
input_power = float(abs(s_in.get_eigenmode_coefficients(mon_in, [1], direction=mp.X).alpha[0, 0, 0]) ** 2)
s_in.reset_meep()
print(f"source check: input flux {total_in:.5e}, mode-1 power {input_power:.5e}, mode-1 share {input_power / total_in:.4f}")
fig, ax = plt.subplots(1, 2, figsize=(10, 3.8))
lim = float(np.max(np.abs(field_src)))
ax[0].imshow(np.real(field_src).T, extent=EXTENT, origin="lower", cmap="RdBu", vmin=-lim, vmax=lim, aspect="equal"); ax[0].set_title("Re(Ez): wavefront", fontsize=9)
ax[1].imshow(np.abs(field_src).T, extent=EXTENT, origin="lower", cmap="inferno", aspect="equal"); ax[1].set_title("|Ez|: envelope", fontsize=9)
for a in ax:
    contour(a, eps_src); a.axvline(SRC_X, color="red", lw=1.2, ls="--"); a.axvline(MON_IN_X, color="blue", lw=1.2, ls=":"); a.set_xlabel("x [um]")
ax[0].set_ylabel("y [um]")
fig.suptitle(f"source check on a straight waveguide: mode-1 share at x = {MON_IN_X} um is {input_power / total_in:.4f}", fontsize=10)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "02_source_check.png"), dpi=150); plt.close(fig)


def fom(x, need_gradient=False):
    """Objective = output-port mode-1 power |a_out|^2 in optimizer units (NOT normalized; see contract 4)."""
    f, dJ = opt([np.clip(x, 0, 1)], need_gradient=need_gradient)
    f = float(np.real(np.asarray(f).squeeze()))
    if not need_gradient:
        return f
    return f, np.squeeze(np.asarray(dJ))


# ---------------------------------------------------------------- forward fields: uniform vs random start; adjoint field
field_fwd, eps_fwd = run_dft_field(sources, geometry_with(x_start))
f_start, g_start = fom(x_start, need_gradient=True)
x_random = np.random.rand(NX * NY)
field_rand, eps_rand = run_dft_field(sources, geometry_with(x_random))
f_random = fom(x_random)
adjoint_sources = opt.adjoint_sources[0]
field_adj, eps_adj = run_dft_field(adjoint_sources, geometry_with(x_start))
print(f"forward: uniform-0.5 FOM = {f_start:.4f} (|grad| = {np.linalg.norm(g_start):.3e}); random start FOM = {f_random:.4f}; "
      f"adjoint sources: {len(adjoint_sources)} x {type(adjoint_sources[0]).__name__}")

fig, ax = plt.subplots(2, 4, figsize=(13, 6.4), gridspec_kw={"width_ratios": [0.55, 1, 1, 1]})
lim = max(np.max(np.abs(field_fwd)), np.max(np.abs(field_rand)))
for r, (weights, fld, eps, tag, val) in enumerate(((x_start, field_fwd, eps_fwd, "uniform 0.5", f_start), (x_random, field_rand, eps_rand, "random seed", f_random))):
    show_design(ax[r, 0], weights, f"design: {tag}\nFOM = {val:.3f}"); ax[r, 0].set_ylabel("y [um]")
    ax[r, 1].imshow(np.real(fld).T, extent=EXTENT, origin="lower", cmap="RdBu", vmin=-lim, vmax=lim, aspect="equal"); ax[r, 1].set_title("forward Re(Ez)", fontsize=9)
    ax[r, 2].imshow(np.abs(fld).T, extent=EXTENT, origin="lower", cmap="inferno", aspect="equal"); ax[r, 2].set_title("forward |Ez|", fontsize=9)
    for a in ax[r, 1:3]:
        contour(a, eps); a.set_xlabel("x [um]")
la = float(np.max(np.abs(field_adj)))
ax[0, 3].imshow(np.real(field_adj).T, extent=EXTENT, origin="lower", cmap="RdBu", vmin=-la, vmax=la, aspect="equal"); ax[0, 3].set_title("adjoint Re(Ez) (source at the output port)", fontsize=9)
ax[1, 3].imshow(np.abs(field_adj).T, extent=EXTENT, origin="lower", cmap="inferno", aspect="equal"); ax[1, 3].set_title("adjoint |Ez|", fontsize=9)
for a in ax[:, 3]:
    contour(a, eps_adj); a.set_xlabel("x [um]")
fig.suptitle("rows: uniform vs random start (forward); right column: the adjoint field of the uniform start", fontsize=10)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "03_fields.png"), dpi=150); plt.close(fig)

# ---------------------------------------------------------------- raw gradient on the 11 x 11 grid
g2 = g_start.reshape(NX, NY)
lim = float(np.max(np.abs(g2)))
fig, ax = plt.subplots(1, 3, figsize=(12, 3.8))
im0 = show_design(ax[0], x_start, "current design (uniform 0.5)"); plt.colorbar(im0, ax=ax[0], fraction=0.046)
im1 = ax[1].imshow(g2.T, origin="lower", extent=DEXT, cmap="RdBu_r", vmin=-lim, vmax=lim, aspect="equal"); ax[1].set_title("raw adjoint gradient dJ/d(density)\nred: more Si helps, blue: more SiO2 helps", fontsize=8); plt.colorbar(im1, ax=ax[1], fraction=0.046)
im2 = ax[2].imshow(np.abs(g2).T, origin="lower", extent=DEXT, cmap="viridis", aspect="equal"); ax[2].set_title("|gradient|: where the design matters most", fontsize=8); plt.colorbar(im2, ax=ax[2], fraction=0.046)
for a in ax[1:]:
    a.set_xlabel("x [um]")
ax[0].set_ylabel("y [um]")
fig.tight_layout(); fig.savefig(os.path.join(OUT, "04_gradient.png"), dpi=150); plt.close(fig)
print(f"gradient: max {g2.max():+.4e}, min {g2.min():+.4e}; positive pixels {int((g2 > 0).sum())}, negative {int((g2 < 0).sum())}")

# ---------------------------------------------------------------- contract 2: gradient gate (uniform 0.5 is already an interior point)
assert np.all((x_start > 0.02) & (x_start < 0.98))
v = g_start / np.linalg.norm(g_start)
adjoint_dd = float(np.dot(g_start, v))
steps = [2e-3, 5e-3, 1e-2]
gate_rows = []
for step in steps:
    fd = (fom(x_start + step * v) - fom(x_start - step * v)) / (2 * step)
    rel = abs(adjoint_dd - fd) / max(abs(fd), 1e-30)
    gate_rows.append({"step": step, "fd": fd, "adjoint": adjoint_dd, "rel_err": rel, "pass": bool(rel <= 0.20 and np.sign(fd) == np.sign(adjoint_dd))})
gradient_gate = all(r["pass"] for r in gate_rows)
print("gate: " + "; ".join(f"step {r['step']:.0e}: FD {r['fd']:.5e} vs adjoint {r['adjoint']:.5e}, rel {r['rel_err']:.4f} {'PASS' if r['pass'] else 'HOLD'}" for r in gate_rows)
      + f" -> gradient gate {'PASS' if gradient_gate else 'HOLD'}")
fig, ax = plt.subplots(1, 2, figsize=(10, 3.4))
idx = np.arange(len(steps))
ax[0].bar(idx - 0.2, [r["fd"] for r in gate_rows], width=0.4, color="tab:orange", label="centred finite difference")
ax[0].bar(idx + 0.2, [adjoint_dd] * 3, width=0.4, color="tab:blue", label="adjoint  g . v")
ax[0].set_xticks(idx); ax[0].set_xticklabels([f"{s:.0e}" for s in steps]); ax[0].set_xlabel("finite-difference step"); ax[0].set_ylabel("directional derivative")
ax[0].set_title("adjoint vs finite difference along the gradient direction", fontsize=9); ax[0].grid(axis="y", alpha=0.3); ax[0].legend(fontsize=8)
bars = ax[1].bar(idx, [r["rel_err"] for r in gate_rows], color=["tab:green" if r["pass"] else "tab:red" for r in gate_rows])
ax[1].axhline(0.20, ls="--", color="crimson", lw=1.2, label="gate: 20 %")
for b, r in zip(bars, gate_rows):
    ax[1].text(b.get_x() + b.get_width() / 2, r["rel_err"] + 0.004, f"{r['rel_err']:.4f}", ha="center", fontsize=8)
ax[1].set_xticks(idx); ax[1].set_xticklabels([f"{s:.0e}" for s in steps]); ax[1].set_ylim(0, 0.25); ax[1].set_ylabel("relative error")
ax[1].set_title(f"gradient gate: {'PASS' if gradient_gate else 'HOLD'}", fontsize=9); ax[1].grid(axis="y", alpha=0.3); ax[1].legend(fontsize=8)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "05_gate.png"), dpi=150); plt.close(fig)
if not gradient_gate:
    raise SystemExit("gradient gate HOLD: do not interpret optimizer results")

# ---------------------------------------------------------------- one manual step, then MMA (contract 3)
one_step = []
for alpha in (0.2, 1.0, 3.0, 8.0):
    x_try = np.clip(x_start + alpha * v, 0, 1)
    one_step.append((alpha, x_try, fom(x_try)))
print("one manual step: " + ", ".join(f"alpha {a} -> {f:.3f} ({f / f_start:.1f}x)" for a, _, f in one_step))

history, design_history = [], []


def nlopt_objective(x, grad):
    f, dJ = fom(x, need_gradient=True)
    if grad.size > 0:
        grad[:] = dJ
    history.append(f); design_history.append(np.array(x, copy=True))
    return f


solver = nlopt.opt(nlopt.LD_MMA, NX * NY)
solver.set_lower_bounds(np.zeros(NX * NY)); solver.set_upper_bounds(np.ones(NX * NY))
solver.set_max_objective(nlopt_objective); solver.set_maxeval(5)
solver.optimize(x_start.copy())
best_k = int(np.argmax(history))
x_optimized = design_history[best_k]                          # keep the best evaluated design (MMA may overshoot)
gray = int(np.sum((x_optimized > 0.02) & (x_optimized < 0.98)))
print("MMA (maxeval 5): " + ", ".join(f"eval {k + 1}: {f:.3f}" for k, f in enumerate(history)) + f"; best eval {best_k + 1} = {max(history):.3f} ({max(history) / history[0]:.1f}x); grayscale pixels {gray}/{NX * NY}")

fig, ax = plt.subplots(2, 6, figsize=(14, 5.6))
show_design(ax[0, 0], x_start, f"start (uniform 0.5)\nFOM {f_start:.2f}"); ax[0, 0].set_ylabel("y [um]")
for a, (alpha, x_try, f_try) in zip(ax[0, 1:5], one_step):
    show_design(a, x_try, f"one step, alpha = {alpha}\nFOM {f_try:.1f}")
ax[0, 5].plot(range(1, len(history) + 1), history, "o-", color="tab:blue"); ax[0, 5].axhline(f_start, ls="--", color="gray", lw=1, label="uniform start")
ax[0, 5].set_xticks(range(1, len(history) + 1)); ax[0, 5].set_xlabel("MMA evaluation"); ax[0, 5].set_ylabel("|a_out|^2 (optimizer units)"); ax[0, 5].set_title("MMA history", fontsize=8); ax[0, 5].grid(alpha=0.3); ax[0, 5].legend(fontsize=7)
for k in range(5):
    show_design(ax[1, k], design_history[k], f"MMA eval {k + 1}  FOM {history[k]:.1f}" + ("  (kept)" if k == best_k else ""))
ax[1, 0].set_ylabel("y [um]")
show_design(ax[1, 5], x_optimized, f"optimized (eval {best_k + 1})\n{gray} grey px of {NX * NY}")
fig.suptitle("top: one manual gradient step (alpha sweep) and the MMA history; bottom: the design at every MMA evaluation", fontsize=10)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "06_step_mma.png"), dpi=150); plt.close(fig)


# ---------------------------------------------------------------- contract 4: fresh simulation, modal power / input mode-1 power
def modal_power(weights, res=RES):
    s = mp.Simulation(geometry=geometry_with(weights), **dict(common, resolution=res))
    mon = s.add_mode_monitor(fcen, 0, 1, mp.ModeRegion(center=mp.Vector3(0, MON_OUT_Y), size=mp.Vector3(2, 0)))
    dft = s.add_dft_fields([mp.Ez], fcen, 0, 1, center=mp.Vector3(), size=mp.Vector3(SX, SY))
    s.run(until_after_sources=stop_cond)
    total = float(mp.get_fluxes(mon)[0])
    mode1 = float(abs(s.get_eigenmode_coefficients(mon, [1], direction=mp.Y).alpha[0, 0, 0]) ** 2)
    field = s.get_dft_array(dft, mp.Ez, 0); eps = s.get_epsilon(); s.reset_meep()
    return mode1, total, field, eps


report = {}
for tag, weights in (("start", x_start), ("optimized", x_optimized)):
    mode1, total, fld, eps = modal_power(weights)
    report[tag] = {"mode1": mode1, "total": total, "T_mode1": mode1 / input_power, "T_total": total / input_power, "field": fld, "eps": eps}
    print(f"verify [{tag}]: mode-1 power {mode1:.4e}, total flux {total:.4e} -> T_mode1 {mode1 / input_power:.4f}, T_total {total / input_power:.4f}")
# resolution check of the final design (same 11 x 11 densities, finer Yee grid)
res_check = {}
for res in (RES, 2 * RES):
    m1, tot, _, _ = modal_power(x_optimized, res=res)
    s_in2 = mp.Simulation(geometry=straight, **dict(common, resolution=res))
    mi = s_in2.add_mode_monitor(fcen, 0, 1, mp.ModeRegion(center=mp.Vector3(MON_IN_X, 0), size=mp.Vector3(0, 2)))
    s_in2.run(until_after_sources=mp.stop_when_fields_decayed(30, mp.Ez, mp.Vector3(MON_IN_X, 0), 1e-5))
    pin = float(abs(s_in2.get_eigenmode_coefficients(mi, [1], direction=mp.X).alpha[0, 0, 0]) ** 2); s_in2.reset_meep()
    res_check[res] = {"T_mode1": m1 / pin, "T_total": tot / pin}
    print(f"resolution check [{res}]: T_mode1 {m1 / pin:.4f}, T_total {tot / pin:.4f}")

fig, ax = plt.subplots(1, 3, figsize=(13, 4.2), gridspec_kw={"width_ratios": [1.1, 1, 1]})
idx = np.arange(2)
tm = [report["start"]["T_mode1"], report["optimized"]["T_mode1"]]; tt = [report["start"]["T_total"], report["optimized"]["T_total"]]
ax[0].bar(idx - 0.2, tm, width=0.4, color="tab:blue", label="T_mode1 (output mode 1)"); ax[0].bar(idx + 0.2, tt, width=0.4, color="tab:gray", label="T_total (all flux)")
for k in range(2):
    ax[0].text(k - 0.2, tm[k] + 0.01, f"{tm[k]:.4f}", ha="center", fontsize=8); ax[0].text(k + 0.2, tt[k] + 0.01, f"{tt[k]:.4f}", ha="center", fontsize=8)
ax[0].set_xticks(idx); ax[0].set_xticklabels(["uniform start", f"after MMA (eval {best_k + 1})"]); ax[0].set_ylim(0, 1.0); ax[0].set_ylabel("normalized to input mode-1 power")
ax[0].set_title("contract 4: measured again in a new simulation", fontsize=9); ax[0].grid(axis="y", alpha=0.3); ax[0].legend(fontsize=7)
lim = max(np.max(np.abs(report["start"]["field"])), np.max(np.abs(report["optimized"]["field"])))
for a, tag in zip(ax[1:], ("start", "optimized")):
    a.imshow(np.real(report[tag]["field"]).T, extent=EXTENT, origin="lower", cmap="RdBu", vmin=-lim, vmax=lim, aspect="equal")
    contour(a, report[tag]["eps"]); a.set_title(f"Re(Ez), {tag}  (T_mode1 = {report[tag]['T_mode1']:.3f})", fontsize=9); a.set_xlabel("x [um]")
ax[1].set_ylabel("y [um]")
fig.tight_layout(); fig.savefig(os.path.join(OUT, "07_verify.png"), dpi=150); plt.close(fig)

# ---------------------------------------------------------------- GIF 1: a short pulse through the optimized bend (source -> output monitor)
fw_anim = 0.3 * fcen
sim_a = mp.Simulation(geometry=geometry_with(x_optimized), **dict(common, sources=[
    mp.EigenModeSource(mp.GaussianSource(fcen, fwidth=fw_anim), eig_band=1, direction=mp.NO_DIRECTION, eig_kpoint=mp.Vector3(1, 0, 0),
                       size=mp.Vector3(0, SRC_SIZE), center=mp.Vector3(SRC_X, 0))]))
sim_a.init_sim()
vol_a = mp.Volume(center=mp.Vector3(), size=mp.Vector3(SX - 2 * DPML, SY - 2 * DPML))
eps_a = sim_a.get_array(vol=vol_a, component=mp.Dielectric)
ext_a = [-(SX / 2 - DPML), SX / 2 - DPML, -(SY / 2 - DPML), SY / 2 - DPML]
t0 = 5 / fw_anim
path = abs(SRC_X) + SY / 2                                    # input straight + output straight, roughly
frames, times = record_frames(sim_a, vol_a, mp.Ez, t_start=t0 - 2 / fw_anim, t_end=t0 + 1.2 * path * 3.4, n_frames=60)
animate_fields(frames, times, ext_a, os.path.join(OUT, "08_anim_optimized.gif"), eps=eps_a, figsize=(6.2, 5.0), dpi=70,
               lines=[((SRC_X, -1), (SRC_X, 1), "red", "source"), ((-1, MON_OUT_Y), (1, MON_OUT_Y), "blue", "output monitor")],
               title="optimized bend", legend_loc="lower right")

# ---------------------------------------------------------------- GIF 2: how the design changed, start -> every MMA eval -> final
evo = [x_start] + design_history + [x_optimized]
evo_lab = ["start"] + [f"eval {k + 1}" for k in range(len(design_history))] + [f"final (eval {best_k + 1})"]
evo_fom = [f_start] + history + [max(history)]
fig_e, ax_e = plt.subplots(figsize=(4.0, 3.8))
im_e = ax_e.imshow(evo[0].reshape(NX, NY).T, origin="lower", extent=DEXT, cmap="gray_r", vmin=0, vmax=1, aspect="equal")
ax_e.set_xlabel("x [um]"); ax_e.set_ylabel("y [um]"); ttl_e = ax_e.set_title("", fontsize=9)
fig_e.colorbar(im_e, ax=ax_e, fraction=0.046, label="density (0 = SiO2, 1 = Si)")
fig_e.tight_layout()


def _evo(i):
    im_e.set_data(evo[i].reshape(NX, NY).T); ttl_e.set_text(f"{evo_lab[i]}   FOM = {evo_fom[i]:.1f}")
    return im_e, ttl_e


animation.FuncAnimation(fig_e, _evo, frames=len(evo), blit=False).save(os.path.join(OUT, "09_anim_design.gif"), writer=animation.PillowWriter(fps=1.5), dpi=80)
plt.close(fig_e)

if mp.am_master():
    with open(os.path.join(OUT, "result.json"), "w") as f:
        json.dump({"params": {"wl": wl, "res": RES, "cell": [SX, SY], "w": W, "design": [D, D], "N": [NX, NY], "fwidth_rel": 0.12},
                   "source_check": {"total_in": total_in, "input_power": input_power, "mode1_share": input_power / total_in},
                   "fom": {"start": f_start, "random": f_random, "grad_norm": float(np.linalg.norm(g_start)),
                           "grad_max": float(g2.max()), "grad_min": float(g2.min()), "grad_pos": int((g2 > 0).sum()), "grad_neg": int((g2 < 0).sum())},
                   "gate": gate_rows, "gate_pass": gradient_gate,
                   "one_step": [{"alpha": a, "fom": f} for a, _, f in one_step],
                   "mma": {"history": history, "best_eval": best_k + 1, "gray_pixels": gray},
                   "verify": {k: {kk: vv for kk, vv in v.items() if kk not in ("field", "eps")} for k, v in report.items()},
                   "resolution_check": res_check,
                   "x_optimized": x_optimized.tolist(),
                   "wall_s_total": time.time() - t_all, "meep": mp.__version__, "nlopt": f"{nlopt.version_major()}.{nlopt.version_minor()}"}, f, indent=2)

§4의 발췌 코드와 달리 전체 코드에는 그림 저장·GIF 두 개·result.json 기록·해상도 20 재측정이 들어 있다. 그림 helper blogfig.py는 시리즈 공통이며 같은 폴더(code/)에 있다. 전체 코드와 helper: https://github.com/jin-castle/meep-examples/blob/main/code.

실행 결과 (2026-10-23 실행):

source check: input flux 2.09705e+02, mode-1 power 2.10614e+02, mode-1 share 1.0043
forward: uniform-0.5 FOM = 4.3095 (|grad| = 3.824e+01); random start FOM = 12.2263; adjoint sources: 1 x EigenModeSource
gradient: max +4.4568e+00, min -1.3404e+01; positive pixels 49, negative 72
gate: step 2e-03: FD 3.82396e+01 vs adjoint 3.82395e+01, rel 0.0000 PASS; step 5e-03: FD 3.82405e+01 vs adjoint 3.82395e+01, rel 0.0000 PASS; step 1e-02: FD 3.82436e+01 vs adjoint 3.82395e+01, rel 0.0001 PASS -> gradient gate PASS
one manual step: alpha 0.2 -> 16.657 (3.9x), alpha 1.0 -> 118.917 (27.6x), alpha 3.0 -> 176.244 (40.9x), alpha 8.0 -> 235.537 (54.7x)
MMA (maxeval 5): eval 1: 4.310, eval 2: 180.684, eval 3: 4.533, eval 4: 106.244, eval 5: 222.402; best eval 5 = 222.402 (51.6x); grayscale pixels 119/121
verify [start]: mode-1 power 3.2469e+00, total flux 2.4546e+01 -> T_mode1 0.0154, T_total 0.1165
verify [optimized]: mode-1 power 1.6429e+02, total flux 1.6933e+02 -> T_mode1 0.7801, T_total 0.8040
resolution check [10]: T_mode1 0.7801, T_total 0.8040
resolution check [20]: T_mode1 0.6391, T_total 0.6870

재현 환경: meep 1.33.0 · nlopt 2.x · autograd · Python 3.11 · conda install -c conda-forge pymeep nlopt autograd · 실행 python bend_inverse.py (약 29 s, 단일 코어)

공식 문서와 이어 읽기

]]>jin-castleMeep Example 06 · Binary grating과 diffraction order — grating equation, 차수별 효율, duty cycle이 만드는 위상2026-10-23T00:00:00+00:002026-10-23T00:00:00+00:00https://jin-castle.github.io/meep-examples/binary-grating English summary
  • What: a glass binary grating under a normally incident plane wave. One period with Bloch-periodic boundaries gives the power in each diffraction order; a subwavelength period gives the amplitude and phase of the only surviving order as the duty cycle changes; a finite 8-ridge grating shows the beams.
  • Result: for a 2.6 µm period only m = 0, ±1 propagate (±36.6°). Power: m = 0 0.759, m = ±1 0.088 each; the orders add up to the transmitted flux and T + R = 0.999. The finite grating’s beams sit at 35.2° by spatial FFT. A duty-cycle sweep of a 1.2 µm period turns the phase by 0.09 × 2π (h = 0.35 µm) or 0.23 × 2π (h = 0.9 µm), close to Δn·h/λ.
  • Takeaway: the grating equation fixes where the light can go; only a simulation says how much goes where. A single period with k_point is enough for the numbers, and DiffractedPlanewave decomposes the transmitted field order by order.
  • Code: full script at the bottom, ~27 s on one core.

1. 관찰 · 빛의 경로를 먼저 보기

유리 막대 8개에 왼쪽에서 평면파를 보냈습니다. 막대 뒤에서 빛이 곧장 가는 방향과 비스듬히 가는 방향으로 나뉩니다. 청록 점선은 방정식으로 예측한 방향이고, 오른쪽 곡선은 실제 필드의 공간 FFT입니다.

유한한 8개 유리 격자 뒤의 세 회절 빔과 산란장 공간 FFT 피크.
유한 격자의 실제 필드입니다. 예측 각도는 0°, ±36.6°이고 FFT에서 읽은 양의 피크는 35.2°입니다. 두 값의 비교에는 유한한 cut 길이의 분해능을 함께 봐야 합니다.
8개 유리 막대 뒤에서 세 회절 빔이 형성되는 펄스의 시간 전개
같은 유한 격자를 짧은 펄스로. 평면파가 막대를 지나는 순간 막대마다 산란파가 생기고, 그것들이 보강되는 세 방향으로만 빔이 자란다. 0차는 곧장, ±1차는 비스듬히.

2. 예측 · 결과를 읽기 전에

파장 1.55 µm에서 주기를 2.6 µm에서 1.2 µm로 줄이면, 공기 쪽으로 전파하는 ±1차 빔은 어떻게 될까요?

먼저 하나를 골라보세요.
예측의 근거 확인하기

두 번째입니다. ±1차는 sin θ = ±λ/Λ를 만족해야 합니다. 1.55/1.2가 1보다 커 실수 각도가 없으므로 공기 중으로 멀리 전파하지 않습니다. 구조 가까이의 소멸장까지 사라진다는 뜻은 아닙니다.

3. 원리 이해하기 · 관찰을 설명하는 방법

왼쪽은 유리에서 공기로 돌출한 한 주기 격자와 y 주기 경계 및 x PML, 오른쪽은 +x 기준 0도와 ±36.6도의 공기 중 회절 방향을 보여준다.
A 실험의 유리(n = 1.5)는 왼쪽에 있고, 유리 돌출부가 오른쪽 공기로 이어집니다. 빛은 유리에서 +x 방향으로 입사합니다. y 방향 주기 2.6 µm, 돌출 높이 0.5 µm, 폭 1.3 µm이며 한 주기 셀은 y 주기 경계와 x PML을 사용합니다. 파장 1.55 µm에서 공기로 전파하는 차수는 0, ±1이며 각도 ±36.6°는 +x 법선 기준입니다. 오른쪽 반복 배열은 방향 설명용이며 별도 유한 8개 격자의 계산 배치와 구분합니다.

방향은 주기와 파장으로 정한다

수직 입사한 빛이 공기로 나갈 때, 주기 Λ는 가로 방향 파수를 차수 m마다 다르게 만듭니다.

\[\sin\theta_m=m\lambda/\Lambda\]

전파하려면 $\lvert m\rvert\lambda/\Lambda<1$이어야 합니다. 주기 2.6 µm와 파장 1.55 µm에서는 m = 0, ±1만 전파하고, ±1차 각도는 법선에서 ±36.6°입니다. 이 식은 갈 수 있는 방향을 알려주며 각 방향의 power는 알려주지 않습니다.

한 주기로 효율을 구하고 전체 합을 확인한다

무한히 반복되는 격자는 막대 하나와 y 방향 주기 경계로 계산합니다. PML은 빛이 진행하는 x 방향에만 둡니다. DiffractedPlanewave로 각 차수의 복소 진폭을 분해한 뒤 입사 flux로 정규화합니다.

\[T_m=\lvert a_m\rvert^2/P_{\mathrm{in}},\qquad \sum_mT_m=T_{\mathrm{total}},\qquad T_{\mathrm{total}}+R\approx1\]

주기 1.2 µm에서는 0차만 전파합니다. 이때 duty cycle(막대 폭/주기)을 바꾸면 빔 개수보다 투과 진폭과 위상이 달라집니다. 유리의 낮은 굴절률 대비 때문에 높이 0.9 µm에서도 위상 변화는 한 바퀴에 못 미칩니다.

기호·설계 가정과 예측표 자세히 보기

주기 Λ의 구조는 평면파에 가로 방향 운동량 2πm/Λ를 더하거나 뺀다. 공기 중에서 전파하려면 가로 파수가 k₀ = 2π/λ보다 작아야 하므로 |m|λ/Λ < 1인 차수만 살아남는다. Λ = 2.6 µm, λ = 1.55 µm면 λ/Λ = 0.60이라 m = 0, ±1까지이고 ±1차는 ±36.6°로 간다. Λ = 1.2 µm면 λ/Λ = 1.29 > 1이라 0차만 남는다. 이때 격자는 “회절”하지 않고 하나의 유효 매질처럼 투과 진폭과 위상만 바꾼다.

\[\sin\theta_m=\frac{m\lambda}{\Lambda},\qquad T_m=\frac{\|a_m\|^2}{P_{\mathrm{in}}},\qquad \sum_m T_m = T_{\mathrm{total}},\qquad T_{\mathrm{total}}+R=1\] \[\frac{\Delta\phi_{\max}}{2\pi}\;\lesssim\;\frac{(n-1)\,h}{\lambda}\]

두 번째 식은 duty cycle로 돌릴 수 있는 위상의 거친 상한이다. 높이 h의 막대를 지나며 쌓이는 위상차의 최대는 막대가 유리로 꽉 찼을 때와 비었을 때의 차, (n − 1)h/λ 바퀴다.

기호 뜻 코드 변수
Λ, h, duty 주기, 막대 높이, 막대 폭/주기 gp, gh, gdc
$a_m$ m차 평면파의 복소 진폭 (DiffractedPlanewave) amp[m]
$P_{\mathrm{in}}$ reference run(유리로 꽉 찬 셀)의 투과 flux P_in
$T_m$, R m차 효율, 반사율(입사장 뺀 flux) T_m[m], R
$k_y/2\pi$ far cut 공간 FFT의 주파수 (cycles/µm) ky

가정과 유효 범위: 2D, Ez 편광, 수직 입사, 손실 없는 유리(n 1.5). 격자는 유리 기판 위의 유리 막대. 유한 격자의 각도는 FFT 분해능 1/(cut 길이) ≈ 0.037 cycles/µm(±1.8°)로 제한된다.

결과 보기 전에 맞춰보기

물리량 내 예측 근거
2.6 µm 주기의 전파 차수 m = 0, ±1 세 개 λ/Λ = 0.60
±1차 각도 ±36.6° asin(0.60)
T₊₁ = T₋₁ 같음 수직 입사 + 대칭 막대
ΣT_m과 T_total, T + R 같음, 1 차수 분해 완비, 손실 없음
1.2 µm 주기의 T_total − T₀ 0 0차만 전파
duty cycle 위상 span (h 0.35 / 0.9 µm) 0.11 / 0.29 × 2π 이하 (n − 1)h/λ
유한 격자 FFT 피크 0.385 cycles/µm (= 1/Λ) 격자 방정식

판정 기준: ΣT_m이 T_total과 1%p 이상 다르면 차수 누락이나 DiffractedPlanewave 설정 오류. T + R이 1에서 1% 이상 벗어나면 reference run이 잘못됐다.

4. 직접 실행 · 변수 하나만 바꾸기

한 번만 바꿔보기: 회절 주기

  1. 전체 코드와 blogfig.py가 있는 code/ 폴더에서 python binary_grating.py를 실행하고 기준 result.json을 보관합니다.
  2. GP_A, GH_A, GDC_A = 2.6, 0.5, 0.5에서 첫 값만 3.5로 바꿉니다. 높이·duty cycle·파장은 그대로 둡니다.
  3. 다시 실행해 orders_propagating의 차수 목록, 각 차수의 T_m, 그 합과 T_total을 비교합니다.

방정식은 ±2차도 전파할 것으로 예측합니다. 새 차수에 얼마가 갈지는 계산으로 확인해야 합니다. 아래 측정 효율은 원래 2.6 µm 주기의 값이며, 3.5 µm의 효율은 새 실험 결과로 채워야 합니다. B 실험의 GP_B = 1.2는 그대로 유지합니다.

계산 배치·광원·파라미터 보기
주기 2.6 µm 격자의 유리 기판, 막대, 광원, flux monitor와 x 방향 PML
실험 A의 한 주기 셀(2.6 µm 높이). 왼쪽 검은 블록 = 유리 기판(PML 관통), 가운데 작은 블록 = 막대(높이 0.5, 폭 1.3 µm), 빨간 선 = 유리 안의 평면파 source, 파란 선 = 반사 monitor(유리)와 투과 monitor(공기), 녹색 빗금 = x 방향 PML. y 방향은 PML이 없고 `k_point`로 주기 경계다. 보라 × = 종료 감시점. 동그라미 숫자는 §4의 단계 번호다.
파라미터 값 왜 이 값인가 바꾸면
주기 Λ (A / B) 2.6 / 1.2 µm A: m = 0, ±1만 전파하도록 공식 10 µm에서 축소. B: 0차만 Λ ≥ 3.1 µm이면 ±2차도 생긴다
막대 h, duty (A) 0.5 µm, 0.5 공식 예제 값 효율 배분이 바뀐다 (§7)
fwidth 0.1 fcen 좁은 대역. 차수 분해는 한 주파수에서 넓히면 차수별 스펙트럼을 얻을 수 있다
RESOLUTION 25 (수렴성 50) 유리 안 파장 1.03 µm → 26 px, 막대 12 px 50에서 소수 셋째 자리가 움직인다
source 유리 안, 셀 전체 폭 주기 셀에서는 폭 = 주기면 평면파 —
reference run 셀 전체가 유리 공식 예제 방식. P_in은 유리 안 입사 flux 공기로 채우면 계면 반사가 분모에 들어간다
유한 격자 ridge 8개, 공기 10 µm, 전면 PML 빔이 분리될 거리. FFT cut은 막대 뒤 8 µm ridge 수가 적으면 빔이 넓어진다
격자 실험의 좁은 대역 가우시안 광원 시간 파형과 스펙트럼
source 파형과 스펙트럼. width 15.5, t0 = 77.5. 대역이 좁아 flux·차수 분해는 fcen 한 점이다.

강의 노트북과의 차이: 강의 week 7은 1.2 µm 주기 하나로 duty cycle sweep을 하고 band 1 mode coefficient를 0차의 대리로 쓴다. 이 글은 공식 예제의 회절 주기(2.6 µm)에서 DiffractedPlanewave로 세 차수를 직접 분해하고, 수지 검산과 유한 격자 실험을 더했다. duty cycle sweep의 수치(위상 span 0.089 × 2π)는 강의와 같다.

코드 단계별 설명 보기

읽는 순서: 단위·파라미터 → 재료·구조 → source → Simulation·경계 → monitor → 실행·종료 → 후처리. 실험 A·B는 같은 함수 run_periodic로, 실험 C는 별도의 유한 셀로 돈다.

① 단위와 파라미터 — 어떤 숫자를 고정하는가

wl = 1.55
fcen = 1 / wl
fwidth = 0.1 * fcen           # narrow band: single-frequency order decomposition
n_glass = 1.5
glass = mp.Medium(index=n_glass)
DPML, DSUB, DPAD = 1.0, 2.0, 2.0

GP_A, GH_A, GDC_A = 2.6, 0.5, 0.5       # A: diffracting period (lambda / GP = 0.60 -> m = 0, +-1 only)
GP_B = 1.2                               # B: subwavelength period (lambda / GP = 1.29 -> m = 0 only)

def orders_propagating(gp):
    """Grating equation at normal incidence: sin(theta_m) = m * wl / gp (into air)."""
    m_max = int(np.floor(gp / wl))
    return {m: float(np.degrees(np.arcsin(m * wl / gp))) for m in range(-m_max, m_max + 1)}
  • 무엇: 파장, 유리, 기판·공기 두께, 두 주기, 그리고 격자 방정식으로 전파 차수 목록을 미리 만든다.
  • 왜: 어떤 차수를 분해할지는 시뮬레이션이 아니라 방정식이 정한다. 전파하지 않는 차수를 DiffractedPlanewave에 넣으면 소멸파라 의미 없는 수가 나온다.
  • 틀리면: m_max를 잘못 세어 ±2차를 넣으면 그 진폭은 소멸파 성분이라 T_m 합이 T_total을 넘거나 들쭉날쭉해진다.

② 재료와 구조 — 무엇이 어디에 있는가

def grating_geometry(sx, gp, gh, gdc):
    return [mp.Block(material=glass, size=mp.Vector3(DPML + DSUB, mp.inf, mp.inf),
                     center=mp.Vector3(-0.5 * sx + 0.5 * (DPML + DSUB), 0)),          # substrate through the PML
            mp.Block(material=glass, size=mp.Vector3(gh, gdc * gp, mp.inf),
                     center=mp.Vector3(-0.5 * sx + DPML + DSUB + 0.5 * gh, 0))]      # the ridge, width gdc * gp
  • 무엇: 왼쪽 PML을 관통하는 유리 기판과, 그 위의 막대 하나. 막대 폭이 duty × 주기다.
  • 왜: 주기 셀에서는 막대 하나가 곧 무한 격자다. 기판은 PML을 관통해야 기판 뒷면 반사가 없다.
  • 틀리면: 기판을 PML 앞에서 끊으면 유리·공기 계면이 하나 더 생겨 R에 4%가 추가된다.

③ Source — 빛을 어떻게 넣는가

def plane_wave(sx, sy, fw=fwidth):
    return [mp.Source(mp.GaussianSource(fcen, fwidth=fw), component=mp.Ez,
                      center=mp.Vector3(-0.5 * sx + DPML + 0.5 * DSUB, 0), size=mp.Vector3(0, sy))]
  • 무엇: 유리 안에서 셀 전체 폭(= 한 주기)에 걸친 선원. +x로 가는 평면파다.
  • 왜: 주기 경계 셀에서 셀 폭 전체의 선원은 그 자체로 무한 평면파다. 03편처럼 is_integrated가 필요 없다. y에는 PML이 없기 때문이다.
  • 틀리면: source를 공기 쪽에 두면 “유리 안 입사 flux” 정규화가 맞지 않는다.

④ Simulation과 경계 — 계산 상자와 PML

sim = mp.Simulation(cell_size=mp.Vector3(sx, gp), resolution=resolution,
                    boundary_layers=[mp.PML(DPML, direction=mp.X)],   # PML only along the propagation axis
                    geometry=[] if empty else grating_geometry(sx, gp, gh, gdc),
                    default_material=glass if empty else mp.air,     # reference: glass everywhere
                    sources=plane_wave(sx, gp), k_point=mp.Vector3())  # Bloch-periodic in y with k = 0
  • 무엇: 높이가 한 주기뿐인 셀. PML은 x에만, y는 k_point=(0,0,0)의 Bloch 주기 경계.
  • 왜: 수직 입사면 Bloch 위상이 0이라 k_point가 영벡터다. reference run은 셀 전체를 유리로 채워 계면 없는 입사 flux를 잰다(공식 예제 방식).
  • 틀리면: k_point를 빼면 y 경계가 반사벽이 되어 격자가 아니라 도파로를 계산한다. PML을 y에도 두면 주기성이 깨진다.

⑤ Monitor — 무엇을 재는가

refl = sim.add_flux(fcen, 0, 1, mp.FluxRegion(center=mp.Vector3(-0.5 * sx + DPML + 0.8 * DSUB, 0), size=mp.Vector3(0, gp)))
tran = sim.add_flux(fcen, 0, 1, mp.FluxRegion(center=mp.Vector3(0.5 * sx - DPML - 0.5 * DPAD, 0), size=mp.Vector3(0, gp)))
...
sim.load_minus_flux_data(refl, refl_data)     # reflection only (03편)
  • 무엇: 유리 안의 반사 monitor(source 하류)와 공기 쪽의 투과 monitor. 둘 다 셀 폭 전체.
  • 왜: 투과 monitor의 flux는 모든 차수의 합이고, 같은 monitor에서 DiffractedPlanewave로 차수를 나눈다. 반사 monitor는 03편 방식으로 입사장을 뺀다.
  • 틀리면: 투과 monitor를 막대에 너무 붙이면 소멸파 차수가 섞여 차수 합이 flux와 어긋난다. 막대에서 한 파장 이상 띄운다.

⑥ 실행과 종료 조건 — 언제 멈추는가

sim.run(until_after_sources=mp.stop_when_fields_decayed(50, mp.Ez, mp.Vector3(0.5 * sx - DPML - 0.5 * DPAD, 0), 1e-6))
  • 무엇: 투과 monitor 위치의 Ez가 10⁻⁶으로 감쇠할 때까지.
  • 왜: 좁은 대역이라 펄스가 길다(width 15.5). 꼬리까지 monitor를 지나야 DFT가 정확하다.
  • 틀리면: 공식 예제처럼 until_after_sources=100 고정 시간을 쓰면 다른 주기·높이에서 부족할 수 있다.

⑦ 후처리 — 숫자로 바꾸기

amp = {m: sim.get_eigenmode_coefficients(tran, mp.DiffractedPlanewave((0, m, 0), mp.Vector3(0, 1, 0), 1, 0)).alpha[0, 0, 0]
       for m in orders}                       # one order per call: (0, m, 0) along the periodic axis y, s-pol (Ez)
T_m = {m: abs(a) ** 2 / P_in for m, a in amp.items()}
phase_m = {m: np.angle(a) for m, a in amp.items()}
T_total = mp.get_fluxes(tran)[0] / P_in
R = -mp.get_fluxes(refl)[0] / P_in
  • 무엇: 차수 m의 평면파 진폭 a_m을 하나씩 구해 |a_m|²/P_in을 효율로, 위각을 위상으로 쓴다.
  • 왜: DiffractedPlanewave((0, m, 0), axis, s, p)는 “주기 방향 y로 m번째 차수, s 편광(Ez)”이라는 하나의 평면파 모드다. get_eigenmode_coefficients는 이 객체를 한 번에 하나만 받는다. 04편의 band 번호 대신 차수를 직접 지정하는 셈이다.
  • 틀리면: 리스트로 여러 DiffractedPlanewave를 넘기면 TypeError가 난다(처음 실행에서 그랬다). axis를 x로 주면 평면 정의가 바뀌어 s·p가 뒤집힌다.

함정: 위상 sweep은 np.unwrap으로 잇는다. 인접 표본의 위상차가 π보다 작을 때만 옳으므로 duty cycle을 촘촘히(9점) 잡는다. 이 글의 최대 인접 차는 0.33 rad이다.

5. 해석 · 측정값과 한계를 함께 읽기

방향 예측과 power 측정을 따로 읽기

차수 공기 중 각도 입사 power 대비 효율
−1 −36.6° 0.0884
0 0° 0.7591
+1 +36.6° 0.0884

차수 합은 0.9358로 전체 투과 flux 0.9358과 맞고, R = 0.0635를 더하면 0.9994입니다. 대칭 구조·수직 입사이므로 ±1차가 같습니다. 해상도 50에서는 T₀ = 0.7597, T±1 = 0.0881로 바뀝니다.

주기 1.2 µm의 duty sweep은 높이 0.35/0.9 µm에서 각각 0.089/0.229 × 2π의 위상 범위를 줍니다. 높이가 커져도 여기서는 2π 전체를 덮지 못해 다음 편의 phase library 설계에 한계가 있습니다.

0차와 ±1차의 측정 효율 및 차수 합과 전체 flux 비교
세 전파 차수의 효율과 검산. m = 0이 0.759, ±1차가 0.088씩. 세 차수의 합 0.936은 투과 monitor의 flux와 같고, 반사 0.064를 더하면 0.999다.
두 막대 높이에서 duty cycle에 따른 0차 투과율과 위상 변화
왼쪽: 0차 투과 T₀. 두 높이 모두 0.83~0.97 사이에서 비단조로 움직인다. 오른쪽: 0차의 위상(duty 0.1 기준, 2π 단위). h = 0.35 µm는 0.09 바퀴, 0.9 µm는 0.23 바퀴를 돈다. 빨간 선이 phase library가 필요로 하는 한 바퀴다.
전체 측정표·예측 비교·수렴성 기록 보기

A. 2.6 µm 주기: 차수별 효율

양 값 (res 25) 값 (res 50) 10_sources 원본 (res 50)
T₀ 0.7591 0.7597 0.7597
T₊₁ = T₋₁ 0.0884 0.0881 0.0881
ΣT_m 0.9358 — 0.9359
T_total (flux) 0.9358 — 0.9359
R 0.0635 0.0639 0.0639
T + R 0.9994 0.9998 0.9998

B. 1.2 µm 주기: duty cycle이 만드는 진폭과 위상

높이 h 위상 span / 2π 어림 (n − 1)h/λ T₀ 범위 max |T_total − T₀|
0.35 µm 0.089 0.113 0.83–0.97 3 × 10⁻⁶
0.90 µm 0.229 0.290 0.85–0.95 3 × 10⁻⁶

C. 유한 격자: 빔과 각도

예측과 비교

물리량 내 예측 (§2) 시뮬레이션 판정
전파 차수 m = 0, ±1 세 차수의 합 = flux ✅
T₊₁ = T₋₁ 같음 0.0884 = 0.0884 ✅
ΣT_m = T_total, T + R 같음, 1 0.9358 = 0.9358, 0.9994 ✅
1.2 µm의 T_total − T₀ 0 3 × 10⁻⁶ ✅
위상 span (0.35 / 0.9 µm) ≤ 0.11 / 0.29 0.089 / 0.229 ✅
FFT 피크 0.385 cycles/µm 0.372 (±0.037 분해능) ✅

모두 맞았다. 위상 span은 어림의 79%다. 막대가 주기를 다 채우지 못하므로 유효 굴절률 차가 (n − 1)보다 작기 때문이고, 어림이 상한이라는 뜻이다. 높이를 2.6배 키워도 0.23바퀴다. 07편의 phase library가 유리 대신 Si를 쓰는 이유가 여기 있다.

수렴성

resolution T₀ T₊₁ R T + R
25 0.7591 0.0884 0.0635 0.9994
50 0.7597 0.0881 0.0639 0.9998

해상도를 2배 올려도 효율은 셋째 자리에서만 움직인다. 막대 높이 0.5 µm가 res 25에서 12 px라 충분하다.

주장할 수 있는 것 / 없는 것

  • 할 수 있는 것: 이 격자에서 수직 입사 Ez 편광의 세 차수 효율은 0.76 / 0.088 / 0.088이고 수지가 닫힌다. subwavelength 유리 격자는 duty cycle로 위상을 (n − 1)h/λ 바퀴 이하만 돌린다.
  • 할 수 없는 것: 유한 격자의 각도를 1° 안으로. FFT cut 길이가 ±1.8° 분해능을 정한다. 비스듬한 입사(Bloch 위상이 0이 아님)와 p 편광. 효율의 파장 의존성(한 주파수만 계산했다).
증상별 점검표 보기
증상 원인 고치는 법
TypeError ... DiffractedPlanewave 여러 차수를 리스트로 넘김 차수마다 get_eigenmode_coefficients를 따로 호출
차수 합이 flux보다 큼 전파하지 않는 차수(소멸파)를 포함 격자 방정식으로 |m|λ/Λ < 1인 것만
격자가 도파로처럼 동작 k_point 누락으로 y 경계가 반사벽 k_point=mp.Vector3()
R이 4%p 큼 기판이 PML 전에 끊김 기판 블록을 PML 관통
위상 곡선이 톱니 unwrap 실패(표본 간격이 넓음) duty cycle 점을 촘촘히
유한 격자 FFT 피크가 넓음 cut이 짧거나 ridge 수가 적음 cut 길이·ridge 수 늘리기

6. 확인 · 두 질문에 답해보기

1. 0차만 전파하면 막대가 빛에 아무 영향도 주지 않는 것일까요?

설명 확인하기

아닙니다. 멀리 전파하는 방향은 하나여도 0차의 진폭과 위상, 그리고 반사율이 바뀝니다. 이 복소 투과계수의 변화를 활용하는 것이 phase library의 출발점입니다.

2. ±1차 각도는 맞는데 차수 합이 전체 투과 flux와 다르면 무엇을 확인할까요?

설명 확인하기

전파하는 차수를 빠뜨렸거나 소멸 차수를 넣지 않았는지, DiffractedPlanewave의 주기 방향·편광 설정과 monitor 위치가 맞는지 확인합니다. 각도 방정식이 맞아도 효율 분해의 검산은 별도로 필요합니다.

7. 참고 · 전체 코드와 원본 기록

아래 전체 프로그램은 원본 그대로입니다. 실행 환경과 결과 기록을 함께 확인하세요.

binary_grating.py (클릭해서 펼치기) 
"""Meep Example 06 - Binary grating and diffraction orders.

  A. One period of a glass binary grating (period 2.6 um > wavelength): the grating equation says only
     m = 0, +-1 propagate in air, at +-36.6 deg. DiffractedPlanewave gives the power in each order;
     checks: sum of orders = total transmitted flux, T + R = 1.  (official binary_grating.py, period reduced)
  B. A subwavelength period (1.2 um): only m = 0 propagates. Sweep the duty cycle and record the
     transmitted amplitude AND phase of the zeroth order, for two ridge heights. This curve is the
     prototype of the meta-atom phase library of post 07; the phase span scales like dn * h / lambda.
  C. A finite grating (8 ridges) with PML on all sides: the three beams become visible; the beam angle
     is read from the spatial FFT of the scattered field on a far cut and compared with the equation.
  D. GIF of C in time.

Run:  python binary_grating.py           (~5 min on one core)
Out:  00_source.png, 01_layout.png, 02_orders.png, 03_duty_sweep.png, 04_finite.png,
      05_anim_finite.gif, result.json   (-> ../assets/06/)
"""
import json
import os
import sys
import time

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import meep as mp

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from blogfig import Label, animate_fields, annotated_layout, bar_figure, record_frames, source_figure   # noqa: E402

OUT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "assets", "06")
os.makedirs(OUT, exist_ok=True)
t_all = time.time()

# ---------------------------------------------------------------- (1) units & parameters
wl = 1.55
fcen = 1 / wl
fwidth = 0.1 * fcen           # narrow band: single-frequency order decomposition
n_glass = 1.5
glass = mp.Medium(index=n_glass)
DPML, DSUB, DPAD = 1.0, 2.0, 2.0

GP_A, GH_A, GDC_A = 2.6, 0.5, 0.5       # A: diffracting period (lambda / GP = 0.60 -> m = 0, +-1 only)
GP_B = 1.2                               # B: subwavelength period (lambda / GP = 1.29 -> m = 0 only)
RESOLUTION = 25


def orders_propagating(gp):
    """Grating equation at normal incidence: sin(theta_m) = m * wl / gp (into air)."""
    m_max = int(np.floor(gp / wl))
    return {m: float(np.degrees(np.arcsin(m * wl / gp))) for m in range(-m_max, m_max + 1)}


# ---------------------------------------------------------------- (2) geometry: substrate + one ridge per period
def grating_geometry(sx, gp, gh, gdc):
    return [mp.Block(material=glass, size=mp.Vector3(DPML + DSUB, mp.inf, mp.inf),
                     center=mp.Vector3(-0.5 * sx + 0.5 * (DPML + DSUB), 0)),          # substrate through the PML
            mp.Block(material=glass, size=mp.Vector3(gh, gdc * gp, mp.inf),
                     center=mp.Vector3(-0.5 * sx + DPML + DSUB + 0.5 * gh, 0))]      # the ridge, width gdc * gp


# ---------------------------------------------------------------- (3) source: plane wave inside the glass, travelling +x
def plane_wave(sx, sy, fw=fwidth):
    return [mp.Source(mp.GaussianSource(fcen, fwidth=fw), component=mp.Ez,
                      center=mp.Vector3(-0.5 * sx + DPML + 0.5 * DSUB, 0), size=mp.Vector3(0, sy))]


# ---------------------------------------------------------------- (4) one periodic cell: PML in x only, Bloch-periodic in y (k = 0)
def periodic_cell(gp, gh, gdc, resolution=RESOLUTION, empty=False):
    sx = DPML + DSUB + gh + DPAD + DPML
    sim = mp.Simulation(cell_size=mp.Vector3(sx, gp), resolution=resolution,
                        boundary_layers=[mp.PML(DPML, direction=mp.X)],
                        geometry=[] if empty else grating_geometry(sx, gp, gh, gdc),
                        default_material=glass if empty else mp.air,     # reference: glass everywhere
                        sources=plane_wave(sx, gp), k_point=mp.Vector3())
    # ------------------------------------------------------------ (5) monitors: reflection (in glass), transmission (in air)
    refl = sim.add_flux(fcen, 0, 1, mp.FluxRegion(center=mp.Vector3(-0.5 * sx + DPML + 0.8 * DSUB, 0), size=mp.Vector3(0, gp)))
    tran = sim.add_flux(fcen, 0, 1, mp.FluxRegion(center=mp.Vector3(0.5 * sx - DPML - 0.5 * DPAD, 0), size=mp.Vector3(0, gp)))
    return sim, refl, tran, sx


def run_periodic(gp, gh, gdc, orders, resolution=RESOLUTION, layout=False):
    """Reference (all glass) then grating. Returns P_in-normalised T_m, T_total, R and the order amplitudes."""
    sim, refl, tran, sx = periodic_cell(gp, gh, gdc, resolution, empty=True)
    sim.run(until_after_sources=mp.stop_when_fields_decayed(50, mp.Ez, mp.Vector3(0.5 * sx - DPML - 0.5 * DPAD, 0), 1e-6))  # (6)
    P_in = float(mp.get_fluxes(tran)[0])                      # incident power per period (measured in glass)
    refl_data = sim.get_flux_data(refl)

    sim, refl, tran, sx = periodic_cell(gp, gh, gdc, resolution)
    sim.load_minus_flux_data(refl, refl_data)
    if layout:
        annotated_layout(
            sim, os.path.join(OUT, "01_layout.png"), dpml=DPML, figsize=(8.6, 4.2),
            title=f"one period: glass substrate + ridge, PML in x only, Bloch-periodic in y (period {gp} um)",
            params_text=f"wl={wl}  res={resolution}\nL={gp} h={gh} dc={gdc}",
            params_xy=(1.5, 1.15), pml_xy=(-2.6, -1.0), decay_point=(0.5 * sx - DPML - 0.5 * DPAD, 0), decay_text_xy=(1.4, -1.0),
            labels=[Label("glass substrate + ridge (geometry)", (-0.5 * sx + DPML + DSUB + 0.25, 0.3), (-2.0, 0.95), step=2, color="black"),
                    Label("plane-wave source in the glass", (-0.5 * sx + DPML + 0.5 * DSUB, -0.6), (-2.3, -1.15), step=3, color="red"),
                    Label("flux: reflection (glass) / transmission (air)", (0.5 * sx - DPML - 0.5 * DPAD, -0.2), (-0.1, -0.55), step=5, color="blue")],
            axis_step=1.0)
    sim.run(until_after_sources=mp.stop_when_fields_decayed(50, mp.Ez, mp.Vector3(0.5 * sx - DPML - 0.5 * DPAD, 0), 1e-6))
    # ------------------------------------------------------------ (7) orders by DiffractedPlanewave, totals by flux
    # one DiffractedPlanewave per call: order m along the periodic direction y, s-polarised (Ez)
    amp = {m: sim.get_eigenmode_coefficients(tran, mp.DiffractedPlanewave((0, m, 0), mp.Vector3(0, 1, 0), 1, 0)).alpha[0, 0, 0]
           for m in orders}
    T_m = {m: float(abs(a) ** 2 / P_in) for m, a in amp.items()}
    phase_m = {m: float(np.angle(a)) for m, a in amp.items()}
    return {"T_m": T_m, "phase_m": phase_m, "T_total": float(mp.get_fluxes(tran)[0] / P_in),
            "R": float(-mp.get_fluxes(refl)[0] / P_in), "P_in": P_in}


source_figure(fcen, fwidth, os.path.join(OUT, "00_source.png"), wl_scale=1000.0, wl_unit="nm", time_unit="um/c")

# ================================================================ A. diffraction orders of the 2.6 um grating
angles = orders_propagating(GP_A)
A = run_periodic(GP_A, GH_A, GDC_A, sorted(angles), layout=True)
sum_orders = sum(A["T_m"].values())
print(f"A. period {GP_A} um: propagating orders {sorted(angles)} at " + ", ".join(f"m={m}: {a:+.1f} deg" for m, a in sorted(angles.items())))
print(f"A. T_m = " + ", ".join(f"m={m}: {t:.4f}" for m, t in sorted(A['T_m'].items())) +
      f"; sum = {sum_orders:.4f}, T_total (flux) = {A['T_total']:.4f}, R = {A['R']:.4f}, T+R = {A['T_total'] + A['R']:.4f}")
bar_figure([f"m = {m}\n({angles[m]:+.1f} deg)" for m in sorted(angles)] + ["sum of orders", "T (flux)", "R", "T + R"],
           {"fraction of incident power": [A["T_m"][m] for m in sorted(angles)] + [sum_orders, A["T_total"], A["R"], A["T_total"] + A["R"]]},
           os.path.join(OUT, "02_orders.png"), ylabel="fraction of incident power", reference=1.0, reference_label="lossless: 1", figsize=(8, 4))
convergence = [{"resolution": RESOLUTION, **{f"T_{m}": A["T_m"][m] for m in sorted(angles)}, "R": A["R"], "T_plus_R": A["T_total"] + A["R"]}]
for res in (50,):
    Ar = run_periodic(GP_A, GH_A, GDC_A, sorted(angles), resolution=res)
    convergence.append({"resolution": res, **{f"T_{m}": Ar["T_m"][m] for m in sorted(angles)}, "R": Ar["R"], "T_plus_R": Ar["T_total"] + Ar["R"]})
    print(f"convergence res={res}: " + ", ".join(f"T_{m}={Ar['T_m'][m]:.4f}" for m in sorted(angles)) + f", R={Ar['R']:.4f}, T+R={Ar['T_total'] + Ar['R']:.4f}")

# ================================================================ B. subwavelength period: duty-cycle sweep of the zeroth order
duty = np.linspace(0.1, 0.9, 9)
sweep = {}
for gh in (0.35, 0.9):
    rows = [run_periodic(GP_B, gh, float(d), [0]) for d in duty]
    T0 = np.array([r["T_m"][0] for r in rows])
    ph = np.unwrap(np.array([r["phase_m"][0] for r in rows]))
    ph -= ph[0]
    step = float(np.max(np.abs(np.diff(ph))))
    sweep[gh] = {"duty": duty.tolist(), "T0": T0.tolist(), "phase": ph.tolist(), "span_over_2pi": float((ph.max() - ph.min()) / (2 * np.pi)),
                 "estimate_dn_h_over_wl": (n_glass - 1) * gh / wl, "max_step_rad": step,
                 "T_total_minus_T0_max": float(max(abs(r["T_total"] - r["T_m"][0]) for r in rows))}
    print(f"B. h={gh}: T0 in [{T0.min():.3f}, {T0.max():.3f}], phase span = {sweep[gh]['span_over_2pi']:.3f} x 2pi "
          f"(estimate dn*h/wl = {sweep[gh]['estimate_dn_h_over_wl']:.3f}), max step {step:.2f} rad, max|T_total - T0| = {sweep[gh]['T_total_minus_T0_max']:.1e}")
fig, ax = plt.subplots(1, 2, figsize=(11, 3.9))
for gh, st in ((0.35, "o-"), (0.9, "s--")):
    ax[0].plot(duty, sweep[gh]["T0"], st, label=f"h = {gh} um")
    ax[1].plot(duty, np.array(sweep[gh]["phase"]) / (2 * np.pi), st, label=f"h = {gh} um  (span {sweep[gh]['span_over_2pi']:.2f}, estimate {sweep[gh]['estimate_dn_h_over_wl']:.2f})")
ax[0].set_xlabel("duty cycle (ridge width / period)"); ax[0].set_ylabel("zeroth-order transmission T0"); ax[0].set_ylim(0, 1.05); ax[0].grid(alpha=0.3); ax[0].legend(fontsize=8)
ax[0].set_title(f"subwavelength period {GP_B} um: amplitude side", fontsize=9)
ax[1].axhline(1.0, color="crimson", ls="--", lw=1.0); ax[1].text(0.12, 1.02, "2 pi (what a phase library needs)", color="crimson", fontsize=8)
ax[1].set_xlabel("duty cycle"); ax[1].set_ylabel("phase of T0 / 2 pi  (relative to duty 0.1)"); ax[1].set_ylim(-0.05, 1.15); ax[1].grid(alpha=0.3); ax[1].legend(fontsize=8)
ax[1].set_title("phase side: prototype of a phase library", fontsize=9)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "03_duty_sweep.png"), dpi=150); plt.close(fig)

# ================================================================ C. finite grating: the beams, and the angle from a spatial FFT
N_RIDGE = 8
RES_C = 15
pad_y = 3.0
sx_c = DPML + DSUB + GH_A + 10.0 + DPML
sy_c = N_RIDGE * GP_A + 2 * pad_y + 2 * DPML
x_ridge = -0.5 * sx_c + DPML + DSUB + 0.5 * GH_A


def finite_geometry(with_ridges):
    g = [mp.Block(material=glass, size=mp.Vector3(DPML + DSUB, mp.inf, mp.inf), center=mp.Vector3(-0.5 * sx_c + 0.5 * (DPML + DSUB), 0))]
    if with_ridges:
        for i in range(N_RIDGE):
            yc = (i - (N_RIDGE - 1) / 2) * GP_A
            g.append(mp.Block(material=glass, size=mp.Vector3(GH_A, GDC_A * GP_A, mp.inf), center=mp.Vector3(x_ridge, yc)))
    return g


def finite_sim(with_ridges, fw=fwidth, resolution=RES_C):
    return mp.Simulation(cell_size=mp.Vector3(sx_c, sy_c), resolution=resolution, boundary_layers=[mp.PML(DPML)],
                         geometry=finite_geometry(with_ridges),
                         sources=[mp.Source(mp.GaussianSource(fcen, fwidth=fw, is_integrated=True), component=mp.Ez,
                                            center=mp.Vector3(-0.5 * sx_c + DPML + 0.5 * DSUB, 0), size=mp.Vector3(0, sy_c))])


nonpml_c = mp.Volume(center=mp.Vector3(), size=mp.Vector3(sx_c - 2 * DPML, sy_c - 2 * DPML))
extent_c = [-(sx_c / 2 - DPML), sx_c / 2 - DPML, -(sy_c / 2 - DPML), sy_c / 2 - DPML]
fields = {}
for tag, ridges in (("flat", False), ("grating", True)):
    sim = finite_sim(ridges)
    dft = sim.add_dft_fields([mp.Ez], fcen, 0, 1, where=nonpml_c)
    sim.run(until_after_sources=mp.stop_when_fields_decayed(50, mp.Ez, mp.Vector3(0.5 * sx_c - DPML - 1.0, 0), 1e-5))
    fields[tag] = sim.get_dft_array(dft, mp.Ez, 0)
    if ridges:
        eps_c = sim.get_array(vol=nonpml_c, component=mp.Dielectric)
ez_sc = fields["grating"] - fields["flat"]                 # scattered field: what the ridges added
nx, ny = ez_sc.shape
xs = np.linspace(extent_c[0], extent_c[1], nx); ys = np.linspace(extent_c[2], extent_c[3], ny)
x_cut = x_ridge + 8.0                                      # far cut, 8 um past the ridges, in homogeneous air
line = ez_sc[np.argmin(abs(xs - x_cut)), :]
ky = np.fft.fftshift(np.fft.fftfreq(ny, d=ys[1] - ys[0]))  # cycles per um
spec = np.abs(np.fft.fftshift(np.fft.fft(line * np.hanning(ny)))) ** 2
spec /= spec.max()
pos = ky > 0.15
k_peak = float(ky[pos][np.argmax(spec[pos])])
theta_meas = float(np.degrees(np.arcsin(min(k_peak * wl, 1.0))))   # sin(theta) = k_y / k0 = k_peak * wl
print(f"C. finite grating ({N_RIDGE} ridges): spatial-FFT peak at {k_peak:.3f} cycles/um -> theta = {theta_meas:.1f} deg "
      f"(grating equation: 1/period = {1/GP_A:.3f} cycles/um -> {angles[1]:.1f} deg)")

fig, ax = plt.subplots(1, 2, figsize=(13, 5.2), gridspec_kw={"width_ratios": [1.5, 1]})
im = ax[0].imshow(np.abs(fields["grating"]).T, origin="lower", extent=extent_c, cmap="inferno", aspect="equal")
ax[0].contour(xs, ys, eps_c.T, levels=[0.5 * (eps_c.min() + eps_c.max())], colors="w", linewidths=0.5)
for m, a in angles.items():
    L = 9.0
    ax[0].plot([x_ridge, x_ridge + L * np.cos(np.radians(a))], [0, L * np.sin(np.radians(a))], "--", color="cyan", lw=1.0)
    ax[0].text(x_ridge + L * np.cos(np.radians(a)) + 0.2, L * np.sin(np.radians(a)), f"m={m:+d}", color="cyan", fontsize=8, va="center")
ax[0].axvline(x_cut, color="lime", ls=":", lw=1.0); ax[0].text(x_cut, extent_c[3] - 0.8, "FFT cut", color="lime", fontsize=8, ha="center")
ax[0].set_xlabel("x [um]"); ax[0].set_ylabel("y [um]"); ax[0].set_title(f"|Ez| at 1550 nm, {N_RIDGE} ridges; dashed = grating-equation angles", fontsize=9)
fig.colorbar(im, ax=ax[0], shrink=0.8)
ax[1].semilogy(ky, spec, color="tab:blue")
for m in (-1, 1):
    ax[1].axvline(m / GP_A, color="crimson", ls="--", lw=0.9)
ax[1].text(1 / GP_A, 1.2, f"+1/period = {1/GP_A:.3f}", color="crimson", fontsize=8, ha="center")
ax[1].set_xlim(-1.2, 1.2); ax[1].set_ylim(1e-4, 3); ax[1].set_xlabel("spatial frequency k_y / 2pi [cycles/um]"); ax[1].set_ylabel("|FFT(E_scat on the cut)|^2 (norm.)")
ax[1].set_title(f"peak {k_peak:.3f} -> {theta_meas:.1f} deg (equation {angles[1]:.1f} deg)", fontsize=9); ax[1].grid(alpha=0.3, which="both")
fig.tight_layout(); fig.savefig(os.path.join(OUT, "04_finite.png"), dpi=150); plt.close(fig)

# ================================================================ D. GIF: the beams forming in time
fw_anim = 0.3 * fcen
sim_anim = finite_sim(True, fw=fw_anim, resolution=12)
sim_anim.init_sim()
eps_anim = sim_anim.get_array(vol=nonpml_c, component=mp.Dielectric)
frames, times = record_frames(sim_anim, nonpml_c, mp.Ez, t_start=5 / fw_anim - 2 / fw_anim, t_end=5 / fw_anim + 1.5 * sx_c + 10, n_frames=60)
animate_fields(frames, times, extent_c, os.path.join(OUT, "05_anim_finite.gif"), eps=eps_anim, figsize=(5.2, 6.4), dpi=70,
               title=f"{N_RIDGE}-ridge grating, plane wave from the left", legend_loc="lower right")

if mp.am_master():
    with open(os.path.join(OUT, "result.json"), "w") as f:
        json.dump({"A": {"period": GP_A, "angles_deg": angles, **{k: A[k] for k in ("T_m", "phase_m", "T_total", "R")}, "sum_orders": sum_orders},
                   "convergence": convergence, "B": {str(k): v for k, v in sweep.items()},
                   "C": {"n_ridges": N_RIDGE, "k_peak_cycles_per_um": k_peak, "theta_meas_deg": theta_meas, "theta_eq_deg": angles[1]},
                   "wall_s_total": time.time() - t_all, "meep": mp.__version__}, f, indent=2)
원본 실행 로그·재현 환경 보기

§4의 발췌 코드와 달리 전체 코드에는 유한 격자 실험(C), 그림 저장·GIF 녹화·result.json 기록이 들어 있다. 그림 helper blogfig.py는 시리즈 공통이며 같은 폴더(code/)에 있다. 전체 코드와 helper: https://github.com/jin-castle/meep-examples/blob/main/code.

실행 결과 (2026-10-23 실행):

A. period 2.6 um: propagating orders [-1, 0, 1] at m=-1: -36.6 deg, m=0: +0.0 deg, m=1: +36.6 deg
A. T_m = m=-1: 0.0884, m=0: 0.7591, m=1: 0.0884; sum = 0.9358, T_total (flux) = 0.9358, R = 0.0635, T+R = 0.9994
convergence res=50: T_-1=0.0881, T_0=0.7597, T_1=0.0881, R=0.0639, T+R=0.9998
B. h=0.35: T0 in [0.829, 0.969], phase span = 0.089 x 2pi (estimate dn*h/wl = 0.113), max step 0.13 rad, max|T_total - T0| = 2.6e-06
B. h=0.9: T0 in [0.846, 0.950], phase span = 0.229 x 2pi (estimate dn*h/wl = 0.290), max step 0.33 rad, max|T_total - T0| = 2.6e-06
C. finite grating (8 ridges): spatial-FFT peak at 0.372 cycles/um -> theta = 35.2 deg (grating equation: 1/period = 0.385 cycles/um -> 36.6 deg)

재현 환경: meep 1.33.0 · Python 3.11 · conda install -c conda-forge pymeep · 실행 python binary_grating.py (약 27 s, 단일 코어)

응용과 다음 학습 주제 보기

어디에 쓰이는가

회절 격자는 분광기, 광섬유 결합기, AR 안경, 홀로그램의 공통 부품이다. 차수별 효율이 그 부품의 성능이다.

응용 이 글의 어떤 것을 쓰는가 그 다음에 필요한 것
분광기·모노크로미터 차수별 효율, grating equation 16편 far field
grating coupler(광섬유 ↔ 칩) 차수 하나로 몰기, 각도 07편 meta-atom
AR 안경의 도파로 격자, 홀로그램, 회절 광학소자(DOE) duty cycle이 만드는 위상 07편 phase library
유한한 격자의 빔 각도 FFT로 잰 회절 각도 16편
]]>jin-castleMeep Example 11 · 두 거울 사이의 점광원 — LDOS와 Purcell 인자2026-10-23T00:00:00+00:002026-10-23T00:00:00+00:00https://jin-castle.github.io/meep-examples/cavity-ldos1. 먼저 보기: 거울은 빛의 양도 바꿀까?

10편에서는 거울 하나가 빛이 나가는 방향을 바꿨습니다. 이번에는 같은 쌍극자를 두 거울 사이에 놓았을 때 방출 power가 얼마나 달라지는지 봅니다. source 위치에서 잰 LDOS를 거울 없는 bulk의 LDOS로 나눈 값이 Purcell 인자입니다.

두 거울 간격에 따른 실제 Purcell 인자와 해석식 및 cylindrical와 3D 결과 비교
파트 A의 실제 결과입니다. 가로축은 정규화 두께 t = nL/λ입니다. cutoff 세 점을 제외한 18점의 해석식 대비 오차는 중앙값 0.94%, 최대 3.6%입니다.

두 실험의 물리량을 구별하세요. 파트 A는 손실 없는 평면 거울 사이에서 bulk로 정규화한 Purcell 인자를 계산합니다. 파트 B는 구멍이 있는 2D PEC 상자의 raw LDOS와 Q/V 근사를 비교합니다. 파트 B의 숫자를 검증된 3D Purcell 인자로 해석할 수 없습니다.

두 평면 거울 사이에서 r 방향으로 퍼지는 실제 cylindrical Er 펄스
파트 A, t = 1.0의 펄스입니다. 두 검은 선이 거울이고 가로는 r, 세로는 z입니다. 읽기 위해 z축을 늘려 그렸으며 실제 비율의 3D 장면은 아닙니다.

2. 먼저 예측하기: 거울을 두면 항상 더 밝아질까?

같은 source를 두 거울 사이에 넣으면 Purcell 인자는 항상 1보다 클까요?
예측과 실제 결과 비교하기

두 번째입니다. t = 1.0에서 cylindrical 계산은 0.912, 3D는 0.933, 해석식은 0.9375입니다. 모두 1보다 작습니다. 거울은 source가 결합할 수 있는 모드를 바꾸므로 방출을 강화할 수도, 억제할 수도 있습니다.

3. 원리 이해하기: 같은 source로 두 번 재는 이유

쌍극자는 자신이 만든 field와 상호작용합니다. 거울에서 돌아온 field가 source 자리의 응답을 바꾸면, 같은 진폭의 전류가 내는 power도 달라집니다. dft_ldos는 source 자리의 field와 전류의 주파수 성분으로 이 응답을 구합니다.

설명용 도식: 같은 source를 거울 없는 bulk와 두 거울 사이에서 계산해 LDOS 비율을 구한다 ① bulk② cavity 같은 source거울 간격 L Purcell 인자 = LDOS② / LDOS①
설명용 도식입니다. 검은 선은 손실 없는 PEC 거울, 청록 점과 가로 화살표는 거울에 평행한 쌍극자입니다. 두 run은 같은 매질과 source 표현을 사용하며, 그림은 실제 field 값이 아닙니다.

F_P = LDOS(cavity) / LDOS(bulk)로 나누면 같은 source·좌표계·격자 정규화의 영향을 비교에서 상쇄할 수 있습니다. cylindrical과 3D는 각각 자신의 bulk run으로 나눠야 합니다.

거울 간격은 매질 안 파장으로 환산한 t = nL/λ로 읽습니다. 이 평면 cavity와 in-plane 쌍극자에서는 t가 0.5, 1.5, 2.5를 지날 때 모드가 새로 열리며 해석식이 불연속으로 뜁니다. 이 지점이 cutoff입니다. 유한 격자와 유한 시간으로 계산한 cutoff 값을 매끈한 구간과 같은 오차 통계에 섞지 않습니다.

평면 cavity의 조건. 파장 1 µm, 굴절률 2.4, 손실 없는 매질·PEC 거울입니다. cylindrical은 Er와 m = −1, 3D는 Ex로 in-plane 쌍극자를 표현합니다. 거울 방향 z에는 PML을 두지 않고 옆으로 나가는 파만 흡수합니다. 손실 매질의 점광원 LDOS에 이 절차를 그대로 적용할 수는 없습니다.

다음으로 파트 B에서는 1 × 1 µm의 2D PEC 상자에 폭 w의 구멍을 냅니다. 구멍이 좁을수록 누설이 줄어 Q가 커지고, 공진 근처 LDOS를 재는 데 필요한 시간도 길어집니다. 이 예제는 2Q/f를 실행 시간의 기준으로 쓰며, 최대 6000에서 자릅니다.

2D PEC 상자 안의 Ez 펄스가 공진하며 폭 0.4 마이크로미터 구멍으로 누설되는 모습
파트 B, w = 0.4 µm의 실제 펄스입니다. 상자 안에서 field가 진동하며 오른쪽 구멍으로 나갑니다. 이 그림은 평면 cavity의 Purcell sweep과 별도인 2D 실험입니다.

4. 직접 실행하기: 높은 Q를 더 오래 관찰하기

Meep 1.33.0 환경에서 저장소의 code/ 폴더에 있는 원본과 공통 helper를 사용합니다. 먼저 원본 결과를 보관하세요. 기존 단일 코어 실행은 약 6.6분입니다.

OMP_NUM_THREADS=1 python cavity_ldos.py

T_MAX만 6000.0에서 12000.0으로 바꿔 같은 명령으로 실행합니다. 이것은 파트 B의 실행 시간 상한 한 가지만 바꾸는 실험입니다. 다른 파라미터와 source는 그대로 둡니다.

w = 0.2의 로그에서 T_run, dft_ldos, 스펙트럼 폭으로 구한 Q를 원본과 비교하세요. 더 긴 계산에서 공진 스펙트럼이 어떻게 변하는지 확인합니다. 원본이 요구한 시간은 23915이므로 12000 역시 그 기준보다 짧습니다. 새 수치를 수렴한 값으로 단정하지 말고, 원본의 3499.1119와 구별해 기록하세요.

5. 결과 해석하기: 큰 Q와 믿을 수 있는 LDOS는 다르다

평면 cavity의 비교 실제 기록
cutoff를 제외한 해석식 대비 오차 중앙값 0.94%, 최대 3.6%
t = 1.0: CYL / 3D / 해석식 0.912 / 0.933 / 0.9375
t = 2.0: CYL / 3D / 해석식 0.988 / 0.979 / 0.9844
t = 1.5 cutoff의 CYL 값 0.507, 아래쪽 해석식 극한 약 0.519에 가까움

3D 확인은 t = 1, 2 두 점뿐입니다. 이 일치가 cutoff 근처를 포함한 모든 두께와 해상도의 검증은 아닙니다. t = 2.5의 CYL 값 1.172는 아래쪽 0.728과 위쪽 1.320 사이에 있어, 한쪽 계단에 정확히 일치한다고 말할 수 없습니다.

2D 상자의 구멍 w Harminv Q 시간 기준 2Q/f 실행 시간 LDOS / (Q/V 기반 추정)
0.2 µm 8060 23915 6000, 상한 도달 0.72
0.3 µm 1271 3802 3802 0.89
0.4 µm 189 574 574 0.85
0.5 µm 74 230 230 0.81

표의 근사값은 2Q/(πωV)이며, V = a²/4는 닫힌 상자의 해석값입니다. 구멍이 있는 상자에는 근사이므로 충분히 실행해도 비가 정확히 1일 필요는 없습니다. w = 0.2에서는 시간까지 부족해 스펙트럼 Q가 5597로 Harminv의 8060보다 작았습니다. 따라서 raw LDOS 3499를 수렴한 값으로 보고하지 않습니다.

6. 이해 확인하기

  1. cavity의 LDOS 하나만 알고 있을 때 “방출이 몇 배 변했다”고 말할 수 없는 이유는 무엇인가요?
  2. w = 0.2에서 Q가 8060으로 측정되었는데도 LDOS를 수렴한 값으로 보고할 수 없는 이유는 무엇인가요?
두 질문의 답 확인하기
  1. 같은 매질·source·좌표계의 bulk 기준값이 필요합니다. 두 LDOS의 비율이 Purcell 인자이고, raw LDOS 하나에는 정규화 조건이 섞여 있습니다.
  2. LDOS 실행은 6000에서 잘렸고 시간 기준 2Q/f는 23915입니다. 공진의 긴 시간 응답을 충분히 포함하지 못했으며 스펙트럼 Q도 다릅니다. 큰 Q 자체가 LDOS 수렴을 보증하지 않습니다.

7. 참고 자료와 전체 코드

원본의 해석식, 좌표계별 설정, 자세한 측정 표와 실행 기록은 아래에서 확인할 수 있습니다.

English summary

TL;DR (English)

두 거울 사이에서 빛의 양은 어떻게 달라질까? — hero 원본 그림
  • What: post 10 put one mirror next to a dipole and the pattern changed. Here the dipole sits between two mirrors and the question is the emitted power itself. Meep measures it as the local density of states (LDOS) at the source point with dft_ldos. Part A: an in-plane dipole in a dielectric slab (n = 2.4) between two lossless metallic mirrors, the Purcell factor F = LDOS(cavity)/LDOS(bulk) versus the normalized thickness t = nL/λ, swept in cylindrical coordinates and checked in 3D. Part B: a dipole in a 2D metal box with one aperture, where the LDOS at resonance is compared with the single-mode estimate 2Q/(πωV).
  • Result: away from the three modal cutoffs the cylindrical sweep matches the analytic curve of Abram et al. with a median error of 0.94% (max 3.6%); at the cutoffs t = 0.5, 1.5, 2.5 the LDOS is discontinuous and FDTD lands on one side of the step. Two full-3D points agree with the cylindrical run to 2.3% / 0.9% (t = 1.0 / 2.0). In the metal box the Harminv Q rises from 74 (w = 0.5) to 8060 (w = 0.2); the directly measured LDOS is 0.81–0.89 of 2Q/(πωV) where the run was long enough, and only 0.72 of it for w = 0.2, whose required run time 2Q/f = 23915 was capped at 6000.
  • Takeaway: a mirror changes not only where light goes but how much is emitted. The Purcell factor is always a ratio of two LDOS runs with the same source. A new cavity mode opens at every half wavelength and the LDOS jumps there. A high-Q LDOS costs a run time of order 2Q/f, and an under-converged LDOS is not a small error but a different number.
  • Code: full script at the bottom, ~6.6 min on one core.
배경·물리식·파라미터 자세히 보기

원본 §0 · 이 글에서 배우는 것

  • LDOS가 무엇인가: 단위 쌍극자가 그 자리에서 내는 power. dft_ldos는 공간 monitor 없이 source 점에서 이것을 잰다
  • Purcell 인자는 LDOS 하나가 아니라 같은 source로 돌린 두 run(cavity, bulk)의 비율이라는 것
  • 두 거울 사이에서 반파장마다 모드가 하나씩 열리고 LDOS가 계단처럼 뛰는 이유. cutoff에서는 비교 자체가 성립하지 않는다
  • in-plane 쌍극자를 cylindrical 좌표의 Er, m = -1로 표현하는 법(13편의 예고)과 3D와의 교차검증
  • z 방향에 PML을 두지 않는 것이 실수가 아니라 거울이라는 물리 조건이라는 것
  • 공진 LDOS ≈ 2Q/(πωV). Harminv의 Q로 필요한 run 시간 2Q/f를 정하고, 짧게 돌리면 어떻게 틀리는지

전제 지식: 10편의 image dipole과 PEC, 01편의 점원. 공식 예제: Local density of states 튜토리얼의 planar cavity with lossless metallic walls와 metal cavity with an aperture, 스크립트 planar_cavity_ldos.py · metal-cavity-ldos.py. 이전 글: 10 · 점광원의 3D 방사 패턴 · 다음 글: 12 · 빛을 가두는 고리

원본 §1 · 무엇을 알고 싶은가

10편의 끝 질문이었다. 거울 하나는 방사 패턴을 다섯 lobe로 바꿨다. 거울 둘 사이에 점광원을 두면 패턴만이 아니라 내는 빛의 양 자체가 바뀌는가. 같은 쌍극자, 같은 진폭인데 주변 구조에 따라 power가 달라진다는 것은 고전 전자기학 안에서 설명된다. 쌍극자가 내는 power는 자기 자신이 만든 field가 자기 전류에 하는 일이고, 거울이 그 field를 되돌려 보내면 일의 양이 바뀐다. 이 양을 재는 물리량이 LDOS이고, bulk 대비 비율이 Purcell 인자다. 두 번째 질문은 가둬 둔 빛에 관한 것이다. 금속 상자에 작은 구멍 하나를 내면 빛이 오래 머물고(Q), 그만큼 LDOS가 커진다는 Q/V 관계가 실제 측정과 맞는가.

어디에 쓰이는가

빛을 가두는 이유는 세 가지다. 첫째, 방출 속도가 바뀐다. 발광 분자가 비발광 경로보다 빨리 빛을 내면 효율이 오른다(Purcell). 둘째, 상호작용 시간이 늘어난다. 같은 재료라도 빛이 Q번 왕복하면 센서·변조기·비선형 효과가 Q배 커진다. 셋째, 주파수를 고른다. 공진 주파수의 빛만 통과시키는 것이 필터와 레이저의 원리다. 이 글의 LDOS와 Q는 세 가지 모두의 기초 수치다.

응용 이 글의 어떤 것을 쓰는가 그 다음에 필요한 것
OLED·LED 내부 효율 Purcell 인자. 전극(거울)과 발광층 두께가 방출 속도를 정한다 14편 광추출 효율
단일광자원(양자점–cavity), 레이저 threshold LDOS, Q/V, 공진 모드의 β 인자 12편 고리, 13편 cylindrical
센서·변조기·비선형 소자 Q로 상호작용 시간을 늘린다 12편 ring, 22편 비선형
필터·파장 분할 다중화(WDM) 공진 주파수 선택, 선폭 f/Q 12편 ring resonator
열방사·복사 냉각 LDOS 그 자체(열 LDOS) —

원본 §2 · 물리 한 페이지

주파수 ω에서 위치 $\mathbf x_0$의 쌍극자 $\hat p$가 내는 power는 그 자리의 전기장이 전류에 하는 일 $-\tfrac12\mathrm{Re}[\hat E\cdot\hat J^*]$에 비례한다. Meep의 dft_ldos는 이것을 단위 쌍극자로 정규화해 돌려준다.

\[\mathrm{LDOS}(\mathbf x_0,\omega)=-\frac{2}{\pi}\,\varepsilon(\mathbf x_0)\, \frac{\mathrm{Re}\big[\hat E_\ell(\mathbf x_0,\omega)\,\hat p(\omega)^*\big]}{\lvert \hat p(\omega)\lvert ^2},\qquad F_P=\frac{\mathrm{LDOS}_{\mathrm{cavity}}}{\mathrm{LDOS}_{\mathrm{bulk}}}\]

분모가 필요한 이유는 분자에 source 진폭, 좌표계, 격자의 정규화가 모두 들어 있기 때문이다. 같은 source 표현으로 bulk를 한 번 더 돌려 나누면 그것들이 상쇄된다. 두 거울 사이의 in-plane 쌍극자에 대해 Abram 등(1998)은 두께 $t=nL/\lambda$의 함수로 닫힌 식을 줬다.

\[F_P(t)=\frac{3N}{4t}+\frac{4N^3-N}{16t^3},\qquad N=\mathrm{fix}\!\left(t+\tfrac12\right)\]

$N$은 거울 사이에 들어가는 모드의 수다. $t$가 반정수를 지날 때마다 모드가 하나 열리고 $F_P$가 뛴다. $t=0.5$에서 3, $t=1.0$에서 0.94, $t=2.0$에서 0.98이다. 뛰는 지점(cutoff)에서는 LDOS가 연속 함수가 아니므로 유한 시간·유한 격자의 FDTD 값은 계단의 어느 쪽에 걸리느냐로 정해진다.

금속 상자의 공진 모드 하나가 LDOS를 지배하면 single-mode 근사가 성립한다.

\[\mathrm{LDOS}(\omega_n)\approx\frac{2}{\pi\,\omega_n}\,\frac{Q_n}{V_n},\qquad V^{(1)}=\frac{a^2}{4},\quad \omega^{(1)}=\frac{\sqrt2\,\pi c}{a}\]

빛이 오래 머물수록($Q$), 좁은 곳에 몰릴수록($V$) 쌍극자가 더 많이 낸다. dft_ldos로 이것을 직접 재려면 DFT가 수렴할 만큼, 즉 field가 다 빠져나갈 만큼 돌려야 하고 그 시간은 $2Q/f$ 정도다.

기호 뜻 코드 변수
$t=nL/\lambda$ 매질 안 파장 단위의 거울 간격 T_NORM
$L$ 실제 거울 간격 $t\lambda/n$ cavity_um
$N$ 열린 모드 수 $\mathrm{fix}(t+\tfrac12)$ np.fix(t + 0.5)
$F_P$ Purcell 인자 purcell_cyl, purcell_3d
$Q$, $f$ 공진의 Q와 주파수 (Harminv) Q, f
$V$ 모드 부피 $a^2/4$ (해석값) V_MODE
$2Q/f$ dft_ldos에 필요한 run 시간 T_req

가정과 유효 범위: 파트 A는 손실 없는 유전체(n = 2.4)와 완전도체 거울, 단일 주파수, 수평 편광 쌍극자. 파트 B는 2D Ez, 완전도체 상자. 모드 부피 $a^2/4$는 닫힌 상자의 해석값이라 구멍이 있는 상자에는 근사다. 손실 매질의 점광원 LDOS는 해상도에 따라 발산하므로 이 글의 방법을 그대로 옮기면 안 된다.

결과 보기 전에 맞춰보기

물리량 내 예측 근거
$F_P(t=1.0)$ 0.94 Eq. 7, $N=1$
cutoff 제외 median 오차 (CYL) 2% 안 노트 0.95%
cutoff 세 점 Eq. 7과 다르다, 어느 쪽 계단인지는 모른다 불연속점
3D(res 48) vs CYL, $t=1,2$ 3% 안 노트의 CYL–3D median 1.3%
$Q$의 w 의존 w 0.5 → 0.2에서 수십 배 구멍이 좁을수록 누설이 준다
$Q$(w = 0.2) 8000 근처 노트 8060
converged run의 LDOS vs $2Q/(\pi\omega V)$ 20% 안 노트 median 15%. $V$가 근사값
w = 0.2 (cap 6000 < 2Q/f) $2Q/(\pi\omega V)$의 절반 아래 노트: 2000 run에서 62%
스펙트럼 FWHM의 $Q$ vs Harminv $Q$ 10% 안 같은 공진

판정 기준: cutoff 밖 median > 5%면 bulk 정규화나 경계(z PML 유무)를 의심한다. converged run에서 LDOS/(Q/V 추정)이 2배 넘게 다르면 Harminv가 다른 모드를 잡은 것이다.

원본 §3 · 시뮬레이션 설계도

파트 A의 cylindrical r–z 셀(t=1.0, L = 0.417 µm). 가로가 반지름 r, 세로가 거울 법선 z. 위아래 셀 벽에 PML이 없다. 그 벽이 완전도체 거울이다. PML은 r 바깥쪽(녹색 빗금)에만 있다. 빨간
파트 A의 cylindrical r–z 셀($t=1.0$, L = 0.417 µm). 가로가 반지름 r, 세로가 거울 법선 z. 위아래 셀 벽에 PML이 없다. 그 벽이 완전도체 거울이다. PML은 r 바깥쪽(녹색 빗금)에만 있다. 빨간 점이 축에서 1.5 픽셀 떨어진 Er 쌍극자.
파트 B의 2D 셀. 완전도체 상자(1 × 1 µm, 벽 0.1 µm)의 오른쪽 벽에 폭 w의 구멍. 가운데 Ez 쌍극자가 Harminv의 probe이자 `dft_ldos`의 점이다. 사방 PML 1 µm. `plot2D`는 `mp.
파트 B의 2D 셀. 완전도체 상자(1 × 1 µm, 벽 0.1 µm)의 오른쪽 벽에 폭 w의 구멍. 가운데 Ez 쌍극자가 Harminv의 probe이자 dft_ldos의 점이다. 사방 PML 1 µm. plot2D는 mp.metal(ε = −∞)을 흰색으로, 공기를 검게 그리므로 흰 테두리가 금속이다. 파란 사각형은 대표 Ez DFT 영역.
파라미터 값 왜 이 값인가 바꾸면
A 파장, n, 해상도 1 µm, 2.4, res 71 공식 값. 매질 안 파장 0.417 µm에 30칸 res가 낮으면 셀 두께가 격자에 반올림되어 계단이 생긴다
A 두께 sweep $t$ = 0.5~2.5, 0.1 간격 21점 공식 41점의 절반. cutoff 세 점 포함 간격을 줄이면 cutoff 근처 계단이 더 보인다
A 3D 확인 $t$ = 1.0, 2.0, res 48 전체 sweep을 3D로 하면 수십 분 두 점만으로 좌표계 교차검증
A bulk 셀 CYL 6 µm, 3D 3 µm (+PML 0.5) 균일 매질이라 크기에 둔감 너무 작으면 PML 반사가 LDOS에 섞인다
A 종료 source 점의 field 감쇠 1e-6 공식 값 cavity run은 z 손실이 없어 bulk보다 오래 걸린다
B 상자, 구멍 a = 1, 벽 0.1, w = 0.2/0.3/0.4/0.5 공식 0.2~0.4에 0.5 추가 w가 작을수록 Q와 필요한 시간이 커진다
B Harminv fcen = √0.5/a = 0.707, df 0.2, 500 time unit 닫힌 상자의 기본 모드 주파수 대역을 넓히면 고차 모드가 섞인다
B dft_ldos 시간 min(2Q/f, 6000) 공식은 cap 없음. w = 0.2는 일부러 미수렴 cap을 없애면 w = 0.2가 수십 분
파트 A의 source 파형과 스펙트럼(1000 nm, fwidth 0.2 fcen). LDOS는 이 대역의 중심 주파수 하나에서 잰다.
파트 A의 source 파형과 스펙트럼(1000 nm, fwidth 0.2 fcen). LDOS는 이 대역의 중심 주파수 하나에서 잰다.

강의 노트북과의 차이: 강의 범위 밖이다. 10_sources의 두 노트는 각각 41점 sweep(CYL + 3D 전체, res 71)과 구멍 세 개(2000 cap)를 돌렸다. 이 글은 sweep을 21점으로 줄이고 3D를 두 점으로 제한한 대신, 구멍에 w = 0.5를 더하고 dft_ldos 스펙트럼의 폭으로 Q를 한 번 더 재서 Harminv와 맞춘다.

원본 코드 단계별 설명

원본 §4 · 코드 따라가기

읽는 순서: 단위·파라미터 → 재료·구조 → source → Simulation·경계 → monitor → 실행·종료 → 후처리. 이번 글의 ⑤는 공간 monitor가 아니라 source 점의 dft_ldos와 Harminv다.

① 단위와 파라미터 — 어떤 숫자를 고정하는가

WL, N_CAV, RES_CYL, RES_3D = 1.0, 2.4, 71, 48
T_NORM = np.round(np.arange(0.5, 2.51, 0.1), 2)       # t = n L / wl; cutoffs at 0.5, 1.5, 2.5
L = t * WL / N_CAV                                     # the physical mirror spacing that goes into the cell

A_BOX, T_WALL, WS = 1.0, 0.1, (0.2, 0.3, 0.4, 0.5)     # metal box, wall, aperture widths
FCEN_M = math.sqrt(0.5) / A_BOX                        # fundamental mode of the closed box
T_MAX = 6000.0                                         # cap on the dft_ldos run
  • 무엇: 파트 A의 두께 sweep과 해상도, 파트 B의 상자와 구멍 폭.
  • 왜: 그림의 가로축은 물리 두께가 아니라 $t=nL/\lambda$다. 셀에는 $L=t\lambda/n$을 넣어야 한다. 상자의 기본 모드는 $\omega=\sqrt2\pi c/a$, 즉 $f=\sqrt{0.5}/a$이고 Harminv의 중심이 된다.
  • 틀리면: $t$를 µm로 그대로 넣으면 거울 간격이 2.4배 넓어지고 Eq. 7과 비교할 수 없다.

② 재료와 구조 — 거울은 PML을 두지 않은 벽

# part A, cavity: PML only in r (cyl) or x, y (3D). The z walls of the cell are Meep's default PEC = the mirrors.
pml = [mp.PML(thickness=DPML, direction=mp.R)]
# part A, bulk: PML on every side, same source, same medium
pml = [mp.PML(thickness=DPML)]
# part B: a metal shell, an air box, and an air block that cuts the aperture into the right wall
geometry = [mp.Block(mp.Vector3(A_BOX + 2 * T_WALL, A_BOX + 2 * T_WALL, mp.inf), material=mp.metal),
            mp.Block(mp.Vector3(A_BOX, A_BOX, mp.inf), material=mp.air),
            mp.Block(center=mp.Vector3(A_BOX / 2), size=mp.Vector3(2 * T_WALL, w, mp.inf), material=mp.air)]
  • 무엇: 파트 A의 거울은 geometry가 아니다. z 방향에 PML이 없으면 셀 벽이 완전도체이고 그것이 거울이다. bulk run은 모든 방향을 PML로 열어 거울을 없앤다. 파트 B는 금속 블록 → 공기 블록 → 구멍 블록 순으로 덮어쓴다.
  • 왜: Purcell 인자는 “거울이 있을 때 / 없을 때”의 비율이다. 두 run의 차이가 경계 조건 하나뿐이어야 한다.
  • 틀리면: cavity run에 z PML을 두면 run은 더 빨리 끝나지만 거울이 없어진다. 10편의 반대 경우다. 그때는 k_point 때문에 벽이 거울이 아니었고, 여기서는 k_point가 없어 벽이 거울이다.

③ Source — in-plane 쌍극자의 두 표현

# cyl: an x-dipole is the m = -1 family of Er; the axis r = 0 is singular, so offset by 1.5 pixels
src_pt = mp.Vector3(1.5 / RES_CYL, 0, 0)
sources = [mp.Source(mp.GaussianSource(FCEN, fwidth=FWIDTH), component=mp.Er, center=src_pt)]
# 3D: the same dipole as Ex at the origin
sources = [mp.Source(mp.GaussianSource(FCEN, fwidth=FWIDTH), component=mp.Ex, center=mp.Vector3())]
  • 무엇: 같은 물리 쌍극자를 cylindrical에서는 Er, m = -1로, 3D에서는 Ex로 둔다.
  • 왜: x 방향 쌍극자의 방위각 의존성은 $e^{\pm i\phi}$, 즉 $m=\pm1$이다. 축 위에서는 r 방향 단위벡터가 정의되지 않으므로 1.5 픽셀 비킨다. 이 offset은 구조 변경이 아니라 좌표 특이점 회피다.
  • 틀리면: offset을 µm 상수로 고정하면 해상도를 바꿀 때 픽셀 단위 표현이 달라진다. 13편에서 cylindrical 좌표를 본격적으로 다룬다.

④ Simulation과 경계 — CYL의 m과 3D의 symmetry 위상

sim = mp.Simulation(resolution=RES_CYL, cell_size=mp.Vector3(cell_r, 0, cell_z), boundary_layers=pml,
                    dimensions=mp.CYLINDRICAL, m=-1, default_material=mp.Medium(index=N_CAV), sources=sources)

sim = mp.Simulation(..., symmetries=[mp.Mirror(mp.X, phase=-1), mp.Mirror(mp.Y), mp.Mirror(mp.Z)])   # 3D: Ex is odd under x
  • 무엇: cylindrical은 dimensions=mp.CYLINDRICAL과 m. 3D는 세 거울 대칭으로 계산을 1/8로.
  • 왜: Ex는 x 반전에서 부호가 바뀌고 y, z 반전에서는 그대로다. 위상은 geometry가 아니라 source 벡터의 parity다.
  • 틀리면: 위상을 전부 +1로 두면 더 빠른 같은 계산이 아니라 다른 parity의 source를 계산한다. 10편의 image dipole에서 Ez가 odd였던 것과 같은 규칙이다.

⑤ Monitor — 공간 monitor 없이 source 점에서

sim.run(mp.dft_ldos(FCEN, 0, 1), until_after_sources=...)          # LDOS at one frequency, at the source point
ldos = sim.ldos_data[0]

h = mp.Harminv(mp.Ez, mp.Vector3(), FCEN_M, DF_M)                   # part B: f and Q of the ringing field
sim.run(mp.after_sources(h), until_after_sources=500)
f, Q = h.modes[0].freq, h.modes[0].Q
sim.run(mp.dft_ldos(f, 8 * f / Q, 101), until_after_sources=min(2 * Q / f, T_MAX))   # spectrum +-4 linewidths around f
  • 무엇: dft_ldos는 step function이다. source 점의 field와 전류의 DFT를 축적해 LDOS를 만든다. Harminv는 source가 꺼진 뒤의 감쇠에서 공진 주파수와 Q를 꺼낸다.
  • 왜: LDOS는 flux가 아니라 source 자리의 일이다. 그래서 flux box가 필요 없고 source 점 하나면 된다. 파트 B에서는 Harminv의 f를 dft_ldos의 주파수로 넘기고, 스펙트럼의 폭으로 Q를 한 번 더 확인한다.
  • 틀리면: dft_ldos의 주파수를 Harminv의 f가 아니라 처음의 fcen으로 두면 공진에서 조금 비껴 LDOS가 작게 나온다. Q가 수천이면 폭이 1e-4라 조금이 크다.

⑥ 실행 — 감쇠 조건과 2Q/f

until_after_sources=mp.stop_when_fields_decayed(20, mp.Er, src_pt, 1e-6)    # part A
until_after_sources=min(2 * Q / f, T_MAX)                                     # part B
  • 무엇: 파트 A는 source 점의 field가 1e-6으로 줄 때까지. 파트 B는 Q로 정한 시간만큼.
  • 왜: Fourier 불확정성 때문에 선폭 $f/Q$를 분해하려면 감쇠 시간 한 주기, $2Q/f$가 필요하다. w = 0.2의 Q는 8000 근처라 $2Q/f\approx 23000$이고, 이 글은 6000에서 자른다. 그 결과가 어떻게 틀리는지를 보여 주기 위해서다.
  • 틀리면: cavity run을 bulk run처럼 짧게 끝내면 거울 사이에 남은 field가 LDOS에 다 더해지지 못한다. 파트 A의 cavity run이 bulk보다 오래 걸리는 것은 정상이다.

⑦ 후처리 — 비율, Eq. 7, Q/V

purcell = ldos_cavity / ldos_bulk                                      # same source, same medium, same coordinates
N = np.fix(t + 0.5); theory = 3 * N / (4 * t) + (4 * N**3 - N) / (16 * t**3)
cutoff = np.isclose(np.mod(t, 1.0), 0.5)                               # exclude from the error statistics, keep the raw values

ldos_qv = Q / V_MODE / (2 * math.pi * f * math.pi * 0.5)               # 2Q / (pi w V), V = a^2 / 4
  • 무엇: Purcell은 비율. Eq. 7과의 오차는 cutoff를 빼고 median과 max를 함께 적는다. 파트 B는 Q/V 추정과 직접 측정을 나란히 둔다.
  • 왜: median만 적으면 $t=1.45$ 같은 국소 실패가 가려진다. cutoff 값은 버리지 않고 표로 남긴다.
  • 틀리면: cutoff의 FDTD 값을 “틀렸다”고 분류하거나 유리한 쪽 계단으로 바꾸면 안 된다. 그 점의 해석값 자체가 두 개다.

함정: Meep은 셀 크기를 픽셀 정수로 반올림한다. $L\times$res가 정수가 아니면 이웃한 두께가 같은 z 격자 수를 쓰게 되어 sweep 곡선에 작은 계단이 생긴다. cutoff 근처에서는 이 반올림이 열린 모드의 표현을 바꿀 수 있다. 로그의 “cell size will be rounded”는 무시할 문자열이 아니다.

원본 결과·검증 표·오류 진단·추가 탐구

원본 §5 · 결과

파트 A. 왼쪽: Purcell 인자 vs t. 검은 선이 Eq. 7, 빨간 점이 cylindrical sweep, 파란 네모가 3D 두 점. 점선이 cutoff. 오른쪽: cutoff를 뺀 상대오차. 회색 막대가 cutoff 세 점
파트 A. 왼쪽: Purcell 인자 vs $t$. 검은 선이 Eq. 7, 빨간 점이 cylindrical sweep, 파란 네모가 3D 두 점. 점선이 cutoff. 오른쪽: cutoff를 뺀 상대오차. 회색 막대가 cutoff 세 점이다.
$t$ Eq. 7 CYL 3D (res 48) 비고
0.5 3.000 3.018 — cutoff
1.0 0.9375 0.912 0.933  
1.5 1.556 (위 계단) / 0.519 (아래) 0.507 — cutoff. FDTD는 아래 계단
2.0 0.9844 0.988 0.979  
2.5 1.320 (위) / 0.728 (아래) 1.172 — cutoff
cutoff 제외 18점 — median 0.94%, max 3.6% (t = 0.70) —  
거울 사이의 정상상태 Re(Er), r–z 평면(z를 늘려 그렸다). t=1.0에서는 z 방향으로 마디 없는 모드 하나가 r 방향으로 퍼져 나간다. t=2.0에서는 z 방향으로 마디가 둘인 모드가 겹쳐 위아래 lobe의 부호가 가운데
거울 사이의 정상상태 Re(Er), r–z 평면(z를 늘려 그렸다). $t=1.0$에서는 z 방향으로 마디 없는 모드 하나가 r 방향으로 퍼져 나간다. $t=2.0$에서는 z 방향으로 마디가 둘인 모드가 겹쳐 위아래 lobe의 부호가 가운데와 반대다. 초록 점이 쌍극자, 색 범위는 source 픽셀을 빼고 잘랐다.
파트 B. 왼쪽: 공진 주변의 `dft_ldos` 스펙트럼. 폭이 f/Q다. 가운데: Q/V 추정(파랑)과 직접 측정(빨강)을 a/w에 대해 semilog로. w = 0.2는 run을 잘라 미수렴. 오른쪽: w = 0.3의 공진 Ez
파트 B. 왼쪽: 공진 주변의 dft_ldos 스펙트럼. 폭이 $f/Q$다. 가운데: Q/V 추정(파랑)과 직접 측정(빨강)을 a/w에 대해 semilog로. w = 0.2는 run을 잘라 미수렴. 오른쪽: w = 0.3의 공진 Ez. 닫힌 상자의 기본 모드 $\sin(\pi x/a)\sin(\pi y/a)$에 구멍 쪽 누설이 더해진 모양.
w f (Harminv) Q (Harminv) Q (스펙트럼 폭) 2Q/f 실행 $2Q/(\pi\omega V)$ dft_ldos 비
0.2 0.6740 8060 5597 (잘린 run) 23915 6000 (cap) 4846 3499 0.72
0.3 0.6688 1271 1324 3802 3802 770 686 0.89
0.4 0.6569 189 196 574 574 116 98 0.85
0.5 0.6465 74 78 230 230 46.7 37.6 0.81

예측과 비교

물리량 내 예측 (§2) 시뮬레이션 판정
$F_P(t=1.0)$ 0.94 0.912 ✅ (2.7% 차)
cutoff 제외 median 오차 2% 안 0.94% ✅
cutoff 세 점 Eq. 7과 다름 0.5: 3.018, 1.5: 0.507, 2.5: 1.172 cutoff: 1.5는 아래쪽에 가깝고, 2.5는 두 극한 사이
3D vs CYL 3% 안 2.3% / 0.9% (t = 1.0 / 2.0) ✅
$Q$의 w 의존 수십 배 74 → 8060 ✅ (109배)
$Q$(w = 0.2) 8000 근처 8060 ✅
converged LDOS vs Q/V 20% 안 0.81~0.89 ✅
w = 0.2 미수렴 절반 아래 0.72 (28% 부족) ❌ (절반보다 위)
스펙트럼 Q vs Harminv Q 10% 안 1324/1271, 196/189, 78/74 (4~5%) ✅

아홉 예측 중 여덟이 맞았다. 틀린 것은 w = 0.2의 미수렴 정도다. 노트는 필요 시간의 8%(2000)만 돌려 62%가 모자랐고, 이 글은 25%(6000)를 돌려 28%가 모자랐다. run을 자르면 공진 봉우리의 꼬리가 DFT에 다 들어오지 못해 LDOS가 작아지고 스펙트럼은 넓어진다. 스펙트럼 폭으로 잰 Q가 5597로 Harminv의 8060보다 작은 것이 그 지문이다. 나머지 세 구멍에서는 스펙트럼 Q와 Harminv Q가 5% 안에서 같고, 직접 잰 LDOS는 Q/V 추정의 81~89%다. 남은 10~20%는 모드 부피 $a^2/4$가 닫힌 상자의 값이라 구멍이 넓을수록 실제 모드가 더 퍼지기 때문이고, 실제로 w가 넓어질수록 비가 0.89에서 0.81로 내려간다. 파트 A에서 $t=1.0$의 CYL 값 0.912는 Eq. 7의 0.9375보다 2.7% 낮지만 3D 값 0.933이 그 사이에 있어 좌표계 표현의 차이로 본다. cutoff에서는 예측대로 FDTD가 계단의 한쪽에 걸렸다. $t=0.5$는 위 계단(3.018 vs 3.0), $t=1.5$는 아래쪽 극한에 가깝고(0.507 vs 0.519), $t=2.5$의 1.172는 아래쪽 0.728과 위쪽 1.320 사이이다.

수렴성

변수 값 결과 비고
A sweep 간격 0.1 (21점, 이 글) vs 0.05 (41점, 노트) median 0.94% vs 0.95% 간격은 오차를 바꾸지 않는다. 각 점이 독립 run
A 3D 해상도 48 (이 글) vs 71 (노트) $t=1,2$에서 CYL과 2.3% / 0.9% (t = 1.0 / 2.0) vs 노트 median 1.3% 노트의 3D max 11.4%($t=1.45$)는 이 글에서 재지 않았다
B run 시간 2Q/f (w ≥ 0.3) vs cap 6000 (w = 0.2) 비 0.81~0.89 vs 0.72 미수렴은 작은 오차가 아니라 다른 숫자

주장할 수 있는 것 / 없는 것

  • 할 수 있는 것: n = 2.4, 완전도체 거울, res 71에서 cylindrical dft_ldos의 Purcell 인자는 cutoff 밖에서 Eq. 7 대비 상대오차 중앙값 0.94%, 최대 3.6%이며, 3D 두 점과 2.3% / 0.9% (t = 1.0 / 2.0) 안에서 같다. 금속 상자에서 Harminv의 Q로 정한 시간만큼 돌리면 직접 잰 LDOS가 $2Q/(\pi\omega V)$와 0.81~0.89 안에서 같다.
  • 할 수 없는 것: cutoff 세 점의 값. 해석식 자체가 불연속이다. 노트가 본 3D의 국소 11% 오차($t=1.45$)는 이 글의 두 점에 없다. 손실 있는 거울이나 매질. 모드 부피 $a^2/4$는 닫힌 상자의 값이라 구멍이 넓어질수록 근사가 나빠진다. w = 0.2의 LDOS는 이 글의 run 시간으로는 모른다.

원본 §6 · 흔한 실수

증상 원인 고치는 법
Purcell이 전부 1 근처 cavity run에 z PML을 둠(거울 없음) cavity는 횡방향만 PML, bulk는 전방향
Purcell이 수십 배 bulk 정규화를 빼먹고 raw LDOS를 봄 같은 source로 bulk를 돌려 나눈다
CYL run이 축에서 발산 Er를 r = 0에 둠 1.5 픽셀 offset
3D 결과가 CYL과 2배 다름 symmetry 위상 전부 +1 Ex는 Mirror(X, phase=-1)
sweep 곡선의 작은 계단 셀 두께가 픽셀로 반올림 $L\times$res가 정수가 되게 고르거나 해상도를 올린다
cutoff에서 50% 오차 불연속점을 일반 점처럼 통계에 넣음 raw 값은 남기고 median에서 뺀다
직접 LDOS가 Q/V의 절반 dft_ldos run이 2Q/f보다 짧음 Q를 먼저 재고 시간을 정한다
r–z field 그림이 뒤집힘, 한 줄만 진함 cylindrical의 get_array·get_dft_array는 (z, r) 순서 2D처럼 전치하지 않는다. 진한 한 줄은 r = 0의 source 열
field 그림이 거의 비어 보임 source 픽셀이 색 범위의 최대값을 차지 99 percentile로 색 범위를 자른다
LDOS가 공진값보다 작음 dft_ldos 주파수를 Harminv의 f가 아니라 fcen으로 Harminv f를 넘긴다

원본 §7 · 직접 해보기

바꿀 것 예상 변화 확인할 수치
파트 A의 쌍극자를 z 방향(Ez, m = 0)으로 수직 쌍극자는 거울 사이에서 다른 곡선 $t<0.5$에서 0이 아닌지
sweep 간격 0.1 → 0.02, $t$ = 1.4~1.6 cutoff 1.5 근처의 계단 모양 어느 $t$에서 뛰는지
파트 A 해상도 50 / 71 / 100 cutoff 밖 median의 사다리 0.94%가 어디서 정체하는지
파트 B의 cap을 없애고 w = 0.2 비가 1 근처로 비, 걸린 시간
파트 B에 w = 0.1 Q 수만, 2Q/f 수십만 Harminv만으로 Q/V 추정
code/cavity_ldos.py 전체 (클릭하여 펼치기) 
"""Meep Example 11 - A point dipole between two mirrors: LDOS and the Purcell factor.

Post 10 showed that one mirror rewrites the radiation pattern. Here the dipole sits between two mirrors and the
question is the emitted POWER itself, measured as the local density of states (LDOS) at the dipole position.
  A. Planar cavity (official planar_cavity_ldos.py): lossless metallic walls, dielectric n = 2.4, in-plane dipole.
     The Purcell factor F = LDOS(cavity) / LDOS(bulk) versus the normalized thickness t = n L / wl, swept in
     cylindrical coordinates (Er, m = -1 represents an x-dipole) and checked at two thicknesses in full 3D.
     Compared with the analytic Eq. 7 of Abram et al. (1998): F = 3N/(4t) + (4N^3 - N)/(16 t^3), N = fix(t + 1/2).
  B. Metal box with an aperture (official metal-cavity-ldos.py, 2D): Harminv gives f and Q of the fundamental mode;
     the LDOS at f is measured directly with dft_ldos and compared with the single-mode estimate 2Q/(pi w V).
     The required run time 2Q/f grows with Q; the narrowest aperture is deliberately left under-converged.

Run:  python cavity_ldos.py       (~15 min on one core)
Out:  00_source.png, 01_layout.png, 02_layout_cyl.png, 03_purcell.png, 04_cavity_field.png, 05_metal_ldos.png,
      06_anim_planar.gif, 07_anim_metal.gif, result.json   (-> ../assets/11/)
"""
import json
import math
import os
import sys
import time

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import meep as mp

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from blogfig import Label, _badge, animate_fields, annotated_layout, record_frames, source_figure   # noqa: E402

HERE = os.path.dirname(os.path.abspath(__file__))
OUT = os.path.join(HERE, "..", "assets", "11")
os.makedirs(OUT, exist_ok=True)
t_all = time.time()

# =================================================================== A. planar cavity with lossless metallic walls
# ---------------------------------------------------------------- (1) parameters (official values; 21-point sweep instead of 41)
WL = 1.0
FCEN = 1 / WL
FWIDTH = 0.2 * FCEN
N_CAV = 2.4
RES_CYL = 71
RES_3D = 48                              # 3D cross-check only (official: 71)
DPML = 0.5
BULK_CYL, BULK_3D = 6.0, 3.0
DECAY_TOL, DECAY_PERIOD = 1e-6, 20
T_NORM = np.round(np.arange(0.5, 2.51, 0.1), 2)          # t = n L / wl; cutoffs at 0.5, 1.5, 2.5
T_3D = (1.0, 2.0)                                         # thicknesses checked in full 3D


def purcell_theory(t):
    N = np.fix(t + 0.5)
    return 3 * N / (4 * t) + (4 * N ** 3 - N) / (16 * t ** 3)


def ldos_cyl(cavity_um=None, *, want_field=False):
    """LDOS of an in-plane dipole (Er, m = -1) in cylindrical coordinates; bulk medium if cavity_um is None."""
    if cavity_um is None:
        cell_z, pml = BULK_CYL + 2 * DPML, [mp.PML(thickness=DPML)]
    else:
        cell_z, pml = cavity_um, [mp.PML(thickness=DPML, direction=mp.R)]      # no z PML: the cell walls are the mirrors
    cell_r = BULK_CYL + DPML
    src_pt = mp.Vector3(1.5 / RES_CYL, 0, 0)                                    # Er at r = 0 is singular: offset by 1.5 px
    sim = mp.Simulation(resolution=RES_CYL, cell_size=mp.Vector3(cell_r, 0, cell_z), boundary_layers=pml, dimensions=mp.CYLINDRICAL, m=-1,
                        default_material=mp.Medium(index=N_CAV),
                        sources=[mp.Source(mp.GaussianSource(FCEN, fwidth=FWIDTH), component=mp.Er, center=src_pt)])
    dft = sim.add_dft_fields([mp.Er], FCEN, 0, 1, center=mp.Vector3(0.5 * BULK_CYL, 0, 0), size=mp.Vector3(BULK_CYL, 0, cell_z)) if want_field else None
    sim.run(mp.dft_ldos(FCEN, 0, 1), until_after_sources=mp.stop_when_fields_decayed(DECAY_PERIOD, mp.Er, src_pt, DECAY_TOL))
    ldos = float(sim.ldos_data[0]); t_end = sim.meep_time()
    field = sim.get_dft_array(dft, mp.Er, 0) if want_field else None
    sim.reset_meep()
    return (ldos, t_end, field) if want_field else (ldos, t_end)


def ldos_3d(cavity_um=None):
    """LDOS of an Ex dipole in full 3D (reduced resolution); bulk if cavity_um is None."""
    if cavity_um is None:
        size_z, pml = BULK_3D + 2 * DPML, [mp.PML(thickness=DPML)]
    else:
        size_z, pml = cavity_um, [mp.PML(thickness=DPML, direction=mp.X), mp.PML(thickness=DPML, direction=mp.Y)]
    size_xy = BULK_3D + 2 * DPML
    sim = mp.Simulation(resolution=RES_3D, cell_size=mp.Vector3(size_xy, size_xy, size_z), boundary_layers=pml,
                        default_material=mp.Medium(index=N_CAV),
                        sources=[mp.Source(mp.GaussianSource(FCEN, fwidth=FWIDTH), component=mp.Ex, center=mp.Vector3())],
                        symmetries=[mp.Mirror(mp.X, phase=-1), mp.Mirror(mp.Y), mp.Mirror(mp.Z)])      # Ex is odd under x, even under y, z
    sim.run(mp.dft_ldos(FCEN, 0, 1), until_after_sources=mp.stop_when_fields_decayed(DECAY_PERIOD, mp.Ex, mp.Vector3(), DECAY_TOL))
    ldos = float(sim.ldos_data[0]); t_end = sim.meep_time(); sim.reset_meep()
    return ldos, t_end


source_figure(FCEN, FWIDTH, os.path.join(OUT, "00_source.png"), wl_scale=1000.0, wl_unit="nm", time_unit="um/c")

# layout of the CYL cavity (r-z plane) at t = 1.0, drawn by hand: the cell is 6.5 x 0.42 um, far too thin for plot2D
L_demo = 1.0 * WL / N_CAV
fig, ax = plt.subplots(figsize=(9.5, 3.6))
ax.axvspan(BULK_CYL, BULK_CYL + DPML, color="green", alpha=0.25)
ax.axhline(0.5 * L_demo, color="k", lw=4); ax.axhline(-0.5 * L_demo, color="k", lw=4)
ax.plot(1.5 / RES_CYL, 0, "o", color="red", ms=7); ax.axvline(0, color="gray", ls="-.", lw=1)
for xy, step, color, txt, txy in (((0.25, 0.5 * L_demo - 0.03), 1, "dimgray", f"wl={WL} um, n={N_CAV}, res={RES_CYL}\ncell r {BULK_CYL + DPML} um x z L={L_demo:.3f} um, m=-1", (0.45, 0.5 * L_demo - 0.03)),
                                   ((3.0, 0.5 * L_demo), 2, "black", "top/bottom cell walls: no PML here, so they are PEC = the two mirrors", (3.2, 0.5 * L_demo - 0.035)),
                                   ((1.5 / RES_CYL, -0.035), 3, "red", "Er dipole (m = -1 = an in-plane dipole) at r = 1.5 px, the axis is singular", (0.45, -0.045)),
                                   ((BULK_CYL + 0.5 * DPML, 0.0), 4, "green", "PML (r only)", (BULK_CYL + 0.08, 0.04)),
                                   ((0.4, 0.07), 5, "blue", "LDOS: dft_ldos at the source point (no spatial monitor); bulk run = same cell with PML on z too", (0.6, 0.06)),
                                   ((1.5 / RES_CYL, 0.11), 6, "purple", "decay watch point = source point", (0.45, 0.10))):
    _badge(ax, xy, step, color); ax.text(*txy, txt, fontsize=8, color=color, va="center")
ax.text(0.05, -0.5 * L_demo + 0.01, "r = 0 (axis)", fontsize=7, color="gray", rotation=90, va="bottom")
ax.set_xlim(-0.1, BULK_CYL + DPML); ax.set_ylim(-0.5 * L_demo - 0.02, 0.5 * L_demo + 0.02)
ax.set_xlabel("r [um]"); ax.set_ylabel("z [um]  (stretched)")
ax.set_title("part A: cylindrical r-z cell at t = 1.0. The z axis is stretched 6x; the real cell is a thin disc between two mirrors", fontsize=9)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "02_layout_cyl.png"), dpi=150); plt.close(fig)

t_a = time.time()
bulk_cyl, t_bulk_cyl = ldos_cyl()
purcell_cyl, t_end_cyl, fields = [], [], {}
for t in T_NORM:
    L = t * WL / N_CAV
    if t in (1.0, 2.0):
        ldos, t_end, fld = ldos_cyl(L, want_field=True); fields[t] = (fld, L)
    else:
        ldos, t_end = ldos_cyl(L)
    purcell_cyl.append(ldos / bulk_cyl); t_end_cyl.append(t_end)
purcell_cyl = np.array(purcell_cyl)
theory = purcell_theory(T_NORM)
cutoff = np.isclose(np.mod(T_NORM, 1.0), 0.5)
err_cyl = np.abs(purcell_cyl - theory) / theory
print(f"A (cyl): bulk LDOS {bulk_cyl:.5f} (t_end {t_bulk_cyl:.0f}); {len(T_NORM)} thicknesses in {time.time() - t_a:.0f} s; "
      f"rel error vs Eq. 7 away from cutoffs: median {np.median(err_cyl[~cutoff]):.4f}, max {err_cyl[~cutoff].max():.4f} at t = {T_NORM[~cutoff][np.argmax(err_cyl[~cutoff])]:.2f}; "
      f"at the cutoffs: " + ", ".join(f"t={t:.1f}: Meep {p:.3f} vs Eq.7 {th:.3f}" for t, p, th in zip(T_NORM[cutoff], purcell_cyl[cutoff], theory[cutoff])))

t_a = time.time()
bulk_3d, t_bulk_3d = ldos_3d()
purcell_3d = {}
for t in T_3D:
    ldos, t_end = ldos_3d(t * WL / N_CAV)
    purcell_3d[t] = ldos / bulk_3d
print(f"A (3D, res {RES_3D}): bulk LDOS {bulk_3d:.5f} (t_end {t_bulk_3d:.0f}); " + ", ".join(f"t={t}: 3D {purcell_3d[t]:.4f} vs cyl {purcell_cyl[np.isclose(T_NORM, t)][0]:.4f} vs Eq.7 {purcell_theory(t):.4f}" for t in T_3D)
      + f"; {time.time() - t_a:.0f} s")

fig, ax = plt.subplots(1, 2, figsize=(12, 4.2), gridspec_kw={"width_ratios": [1.5, 1]})
tt = np.linspace(0.5, 2.5, 801)
ax[0].plot(tt, purcell_theory(tt), "-", color="k", lw=1.2, label="Eq. 7 (Abram 1998)")
ax[0].plot(T_NORM, purcell_cyl, "o", color="tab:red", ms=5, label=f"Meep cylindrical (Er, m = -1), res {RES_CYL}")
ax[0].plot(list(T_3D), [purcell_3d[t] for t in T_3D], "s", color="tab:blue", ms=7, label=f"Meep 3D (Ex), res {RES_3D}")
for tc in (0.5, 1.5, 2.5):
    ax[0].axvline(tc, color="gray", ls=":", lw=1)
ax[0].axhline(1, color="gray", ls="--", lw=1); ax[0].text(2.3, 1.03, "bulk", fontsize=8, color="gray")
ax[0].set_xlabel("normalized cavity thickness t = n L / wavelength"); ax[0].set_ylabel("Purcell factor  LDOS(cavity) / LDOS(bulk)")
ax[0].set_title("in-plane dipole between two lossless mirrors (n = 2.4): a new mode opens at every half-integer", fontsize=9)
ax[0].set_ylim(0.4, 3.2); ax[0].grid(alpha=0.3); ax[0].legend(fontsize=8)
ax[1].bar(T_NORM[~cutoff], 100 * err_cyl[~cutoff], width=0.07, color="tab:red", alpha=0.7, label="cylindrical")
ax[1].bar(T_NORM[cutoff], 100 * err_cyl[cutoff], width=0.07, color="lightgray", label="at a cutoff (excluded)")
for t in T_3D:
    ax[1].plot(t, 100 * abs(purcell_3d[t] - purcell_theory(t)) / purcell_theory(t), "s", color="tab:blue", ms=7)
ax[1].set_xlabel("t"); ax[1].set_ylabel("|Meep - Eq. 7| / Eq. 7  [%]"); ax[1].set_title(f"error: median {100 * np.median(err_cyl[~cutoff]):.2f} % away from cutoffs", fontsize=9)
ax[1].grid(axis="y", alpha=0.3); ax[1].legend(fontsize=8)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "03_purcell.png"), dpi=150); plt.close(fig)

fig, ax = plt.subplots(2, 1, figsize=(10, 5.2))
for a, t in zip(ax, (1.0, 2.0)):
    fld, L = fields[t]
    # NOTE: in cylindrical coordinates get_dft_array / get_array return (z, r), not (r, z): no transpose here
    fld = fld[2:-2, :]                                      # drop the two grid rows touching each mirror (boundary pixels of the DFT array)
    nz = fld.shape[0]; dz = L / (nz + 4)
    ext = [0, BULK_CYL, -0.5 * L + 2 * dz, 0.5 * L - 2 * dz]
    lim = float(np.percentile(np.abs(fld), 99.5))           # the source pixel dominates the maximum: clip the colour scale
    a.imshow(np.real(fld), extent=ext, origin="lower", cmap="RdBu", vmin=-lim, vmax=lim, aspect="auto")
    a.axhline(0.5 * L, color="k", lw=2); a.axhline(-0.5 * L, color="k", lw=2); a.plot(1.5 / RES_CYL, 0, "o", color="lime", ms=4)
    a.set_title(f"Re(Er) at t = {t:.1f} (L = {L:.3f} um): F = {purcell_cyl[np.isclose(T_NORM, t)][0]:.3f}   (thick black lines = mirrors)", fontsize=9)
    a.set_ylabel("z [um]")
ax[1].set_xlabel("r [um]")
fig.suptitle("part A: steady-state field between the mirrors, cylindrical r-z plane", fontsize=10)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "04_cavity_field.png"), dpi=150); plt.close(fig)

# GIF: a short pulse between the mirrors at t = 1.0 (r-z plane)
L = 1.0 * WL / N_CAV
fw_anim = 0.5 * FCEN
sim_g = mp.Simulation(resolution=RES_CYL, cell_size=mp.Vector3(BULK_CYL + DPML, 0, L), boundary_layers=[mp.PML(thickness=DPML, direction=mp.R)],
                      dimensions=mp.CYLINDRICAL, m=-1, default_material=mp.Medium(index=N_CAV),
                      sources=[mp.Source(mp.GaussianSource(FCEN, fwidth=fw_anim), component=mp.Er, center=mp.Vector3(1.5 / RES_CYL, 0, 0))])
sim_g.init_sim()
vol_g = mp.Volume(center=mp.Vector3(0.5 * BULK_CYL, 0, 0), size=mp.Vector3(BULK_CYL, 0, L))
t0g = 5 / fw_anim
frames, times = record_frames(sim_g, vol_g, mp.Er, t_start=t0g - 2 / fw_anim, t_end=t0g + 1.1 * BULK_CYL * N_CAV, n_frames=60)
frames = [f.T for f in frames]                      # cylindrical get_array returns (z, r); animate_fields expects (x, y) = (r, z)
animate_fields(frames, times, [0, BULK_CYL, -0.5 * L, 0.5 * L], os.path.join(OUT, "06_anim_planar.gif"), figsize=(7.5, 2.8), dpi=70, aspect="auto",
               component="Er", unit="um", xlabel="r [um]", ylabel="z [um] (stretched)", clip_percentile=99.0,
               lines=[((0, 0.5 * L), (BULK_CYL, 0.5 * L), "k", "mirrors (cell walls)"), ((0, -0.5 * L), (BULK_CYL, -0.5 * L), "k", "_nolegend_")],
               points=[(1.5 / RES_CYL, 0, "red", "dipole")], title="planar cavity, t = 1.0", legend_loc="upper right")
sim_g.reset_meep()

# =================================================================== B. metal box with an aperture (2D), official metal-cavity-ldos.py
RES_M = 50
A_BOX, T_WALL, DPML_M = 1.0, 0.1, 1.0
SXY = 2.0 + 2 * DPML_M
FCEN_M = math.sqrt(0.5) / A_BOX                      # fundamental mode of the closed a x a box
DF_M = 0.2
WS = (0.2, 0.3, 0.4, 0.5)
T_MAX = 6000.0                                        # cap on the dft_ldos run (the official 2Q/f is not capped)
V_MODE = 0.25 * A_BOX ** 2                            # modal volume of the fundamental mode, analytic


def metal_box(w):
    return [mp.Block(mp.Vector3(A_BOX + 2 * T_WALL, A_BOX + 2 * T_WALL, mp.inf), material=mp.metal),
            mp.Block(mp.Vector3(A_BOX, A_BOX, mp.inf), material=mp.air),
            mp.Block(center=mp.Vector3(A_BOX / 2), size=mp.Vector3(2 * T_WALL, w, mp.inf), material=mp.air)]     # the aperture in the right wall


def make_sim(w, sources):
    return mp.Simulation(cell_size=mp.Vector3(SXY, SXY), geometry=metal_box(w), boundary_layers=[mp.PML(DPML_M)], sources=sources,
                         symmetries=[mp.Mirror(mp.Y)], resolution=RES_M)


src_M = [mp.Source(mp.GaussianSource(FCEN_M, fwidth=DF_M), component=mp.Ez, center=mp.Vector3())]
sim_lay = make_sim(0.3, src_M)
sim_lay.add_dft_fields([mp.Ez], FCEN_M, 0, 1, center=mp.Vector3(), size=mp.Vector3(2, 2))
annotated_layout(sim_lay, os.path.join(OUT, "01_layout.png"), dpml=DPML_M, figsize=(6.4, 6.0), axis_step=1.0,
                 title="part B: metal box 1 x 1 um, wall 0.1, aperture w = 0.3 (plot2D draws mp.metal white)",
                 params_text=f"a={A_BOX}, t={T_WALL}, res={RES_M}\nfcen=sqrt(0.5)/a={FCEN_M:.3f}", params_xy=(-1.9, 1.75),
                 pml_xy=(-1.9, -1.5), decay_point=None,
                 labels=[Label("Ez dipole at the center: Harminv probe and dft_ldos point", (0.02, 0.0), (-1.9, 1.2), step=3, color="red"),
                         Label("metal walls (mp.metal)", (-0.55, 0.3), (-1.9, 0.75), step=2, color="black"),
                         Label("aperture w: the only leak", (0.6, 0.0), (0.75, -0.9), step=2, color="black"),
                         Label("DFT Ez map (representative)", (-0.9, -0.9), (-1.9, -1.2), step=5, color="blue")])
sim_lay.reset_meep()

res_M = {}
t_b = time.time()
for w in WS:
    sim = make_sim(w, src_M)
    h = mp.Harminv(mp.Ez, mp.Vector3(), FCEN_M, DF_M)
    sim.run(mp.after_sources(h), until_after_sources=500)
    modes = [m for m in h.modes if m.Q > 0]
    m = max(modes, key=lambda mm: mm.Q)
    f, Q = float(m.freq), float(m.Q)
    sim.reset_meep()
    ldos_qv = Q / V_MODE / (2 * math.pi * f * math.pi * 0.5)          # 2Q / (pi w V), w = 2 pi f
    T_req = 2 * Q / f
    T_run = min(T_req, T_MAX)
    sim = make_sim(w, src_M)
    nfreq = 101
    df_spec = 8 * f / Q                                               # spectrum: +-4 linewidths around the Harminv frequency
    dft = sim.add_dft_fields([mp.Ez], f, 0, 1, center=mp.Vector3(), size=mp.Vector3(2, 2)) if w == 0.3 else None
    sim.run(mp.dft_ldos(f, df_spec, nfreq), until_after_sources=T_run)
    freqs = np.array(sim.ldos_freqs if hasattr(sim, "ldos_freqs") else np.linspace(f - 0.5 * df_spec, f + 0.5 * df_spec, nfreq))
    spec = np.array(sim.ldos_data)
    ez = sim.get_dft_array(dft, mp.Ez, 0) if dft is not None else None
    sim.reset_meep()
    ldos_f = float(spec[nfreq // 2])
    half = spec >= 0.5 * spec.max()
    fwhm = float(freqs[half].max() - freqs[half].min()) if half.sum() > 1 else float("nan")
    res_M[w] = {"f": f, "Q": Q, "ldos_qv": ldos_qv, "ldos_dft": ldos_f, "T_req": T_req, "T_run": T_run, "converged": T_run >= T_req,
                "spec_f": freqs, "spec": spec, "fwhm": fwhm, "Q_spec": f / fwhm if fwhm == fwhm else float("nan"), "ez": ez}
    print(f"B [w = {w}]: Harminv f {f:.5f}, Q {Q:.0f}; 2Q/f = {T_req:.0f} -> ran {T_run:.0f}{'' if T_run >= T_req else ' (CAPPED, under-converged)'}; "
          f"LDOS: Q/V estimate {ldos_qv:.4f}, dft_ldos {ldos_f:.4f}, ratio {ldos_f / ldos_qv:.3f}; spectrum FWHM {fwhm:.2e} -> Q {f / fwhm if fwhm == fwhm else float('nan'):.0f}")
print(f"B done in {time.time() - t_b:.0f} s")

fig = plt.figure(figsize=(13.5, 4.4))
ax = fig.add_subplot(1, 3, 1)
for w, c in zip(WS, ("tab:red", "tab:orange", "tab:green", "tab:blue")):
    r = res_M[w]
    ax.plot((r["spec_f"] - r["f"]) / r["f"] * 1e3, r["spec"] / r["spec"].max(), "-", color=c, lw=1.4, label=f"w = {w}: Q_Harminv {r['Q']:.0f}, Q_spectrum {r['Q_spec']:.0f}" + ("" if r["converged"] else " (capped)"))
ax.set_xlabel("(f - f_res) / f_res  [x 1e-3]"); ax.set_ylabel("LDOS / peak"); ax.set_title("dft_ldos spectrum around the resonance: width = f / Q", fontsize=9); ax.grid(alpha=0.3); ax.legend(fontsize=7)
ax = fig.add_subplot(1, 3, 2)
inv_w = [A_BOX / w for w in WS]
ax.semilogy(inv_w, [res_M[w]["ldos_qv"] for w in WS], "bo-", label="2Q / (pi w V)  (Harminv Q, analytic V)")
ax.semilogy(inv_w, [res_M[w]["ldos_dft"] for w in WS], "rs-", label="dft_ldos at f_res")
for w in WS:
    if not res_M[w]["converged"]:
        ax.annotate("under-converged\n(run capped)", (A_BOX / w, res_M[w]["ldos_dft"]), textcoords="offset points", xytext=(-70, -28), fontsize=7, arrowprops=dict(arrowstyle="->", lw=0.8))
ax.set_xlabel("a / w"); ax.set_ylabel("LDOS at the resonance"); ax.set_title("narrower aperture: higher Q, higher LDOS", fontsize=9); ax.grid(alpha=0.3, which="both"); ax.legend(fontsize=7)
ax = fig.add_subplot(1, 3, 3)
ez = res_M[0.3]["ez"]; lim = float(np.percentile(np.abs(ez), 96.0))     # clip: the source pixel dominates, and 3/4 of the map is outside the box
ax.imshow(np.real(ez).T, extent=[-1, 1, -1, 1], origin="lower", cmap="RdBu", vmin=-lim, vmax=lim, aspect="equal")
ax.add_patch(plt.Rectangle((-0.5, -0.5), 1, 1, fill=False, color="k", lw=1.2)); ax.add_patch(plt.Rectangle((0.5, -0.15), 0.2, 0.3, fill=False, color="k", lw=1.0, ls="--"))
ax.set_title(f"Re(Ez) at f_res, w = 0.3: fundamental mode sin(pi x/a) sin(pi y/a)", fontsize=9); ax.set_xlabel("x [um]"); ax.set_ylabel("y [um]")
fig.suptitle("part B: a point dipole in a metal box with one aperture", fontsize=10)
fig.tight_layout(rect=[0, 0, 1, 0.93]); fig.savefig(os.path.join(OUT, "05_metal_ldos.png"), dpi=150); plt.close(fig)

# GIF: the box rings and leaks through the aperture (w = 0.4, monitor-free)
sim_g = make_sim(0.4, [mp.Source(mp.GaussianSource(FCEN_M, fwidth=0.4 * FCEN_M), component=mp.Ez, center=mp.Vector3())])
sim_g.init_sim()
vol_g = mp.Volume(center=mp.Vector3(), size=mp.Vector3(2, 2))
eps_g = sim_g.get_array(vol=vol_g, component=mp.Dielectric)
eps_g = np.where(np.isfinite(eps_g), eps_g, 100.0)
t0g = 5 / (0.4 * FCEN_M)
frames, times = record_frames(sim_g, vol_g, mp.Ez, t_start=t0g - 2 / (0.4 * FCEN_M), t_end=t0g + 40, n_frames=60)
animate_fields(frames, times, [-1, 1, -1, 1], os.path.join(OUT, "07_anim_metal.gif"), eps=eps_g, figsize=(5.4, 4.8), dpi=70, clip_percentile=99.0,
               points=[(0, 0, "red", "dipole")], lines=[((0.6, -0.2), (0.6, 0.2), "blue", "aperture w = 0.4")], title="metal box", legend_loc="lower left")
sim_g.reset_meep()

if mp.am_master():
    with open(os.path.join(OUT, "result.json"), "w") as f_:
        json.dump({"A": {"wl": WL, "n": N_CAV, "res_cyl": RES_CYL, "res_3d": RES_3D, "t": T_NORM.tolist(), "purcell_cyl": purcell_cyl.tolist(), "theory": theory.tolist(),
                         "err_cyl": err_cyl.tolist(), "cutoff": cutoff.tolist(), "median_err_away": float(np.median(err_cyl[~cutoff])), "max_err_away": float(err_cyl[~cutoff].max()),
                         "bulk_cyl": bulk_cyl, "bulk_3d": bulk_3d, "purcell_3d": {str(k): v for k, v in purcell_3d.items()}, "t_end_cyl": [float(x) for x in t_end_cyl]},
                   "B": {str(w): {k: (v.tolist() if isinstance(v, np.ndarray) else v) for k, v in r.items() if k != "ez"} for w, r in res_M.items()},
                   "wall_s_total": time.time() - t_all, "meep": mp.__version__}, f_, indent=2)
print(f"total {time.time() - t_all:.0f} s")
원본 실행 기록과 재현 환경

§4의 발췌 코드와 달리 전체 코드에는 cylindrical 설계도, r–z field 그림, 스펙트럼 그림, GIF 두 개, result.json 기록이 들어 있다. 그림 helper blogfig.py는 시리즈 공통이며 같은 폴더(code/)에 있다. 전체 코드와 helper: https://github.com/jin-castle/meep-examples/blob/main/code.

실행 결과 (2026-10-23 실행):

A (cyl): bulk LDOS 0.41625 (t_end 80); 21 thicknesses in 138 s; rel error vs Eq. 7 away from cutoffs: median 0.0094, max 0.0360 at t = 0.70; at the cutoffs: t=0.5: Meep 3.018 vs Eq.7 3.000, t=1.5: Meep 0.507 vs Eq.7 1.556, t=2.5: Meep 1.172 vs Eq.7 1.320
A (3D, res 48): bulk LDOS 3.22287 (t_end 80); t=1.0: 3D 0.9330 vs cyl 0.9120 vs Eq.7 0.9375, t=2.0: 3D 0.9788 vs cyl 0.9879 vs Eq.7 0.9844; 127 s
B [w = 0.2]: Harminv f 0.67403, Q 8060; 2Q/f = 23915 -> ran 6000 (CAPPED, under-converged); LDOS: Q/V estimate 4846.1525, dft_ldos 3499.1119, ratio 0.722; spectrum FWHM 1.20e-04 -> Q 5597
B [w = 0.3]: Harminv f 0.66875, Q 1271; 2Q/f = 3802 -> ran 3802; LDOS: Q/V estimate 770.3846, dft_ldos 685.5049, ratio 0.890; spectrum FWHM 5.05e-04 -> Q 1324
B [w = 0.4]: Harminv f 0.65692, Q 189; 2Q/f = 574 -> ran 574; LDOS: Q/V estimate 116.3766, dft_ldos 98.4505, ratio 0.846; spectrum FWHM 3.34e-03 -> Q 196
B [w = 0.5]: Harminv f 0.64648, Q 74; 2Q/f = 230 -> ran 230; LDOS: Q/V estimate 46.6641, dft_ldos 37.5608, ratio 0.805; spectrum FWHM 8.34e-03 -> Q 78
B done in 118 s
total 396 s

재현 환경: meep 1.33.0 · Python 3.11 · conda install -c conda-forge pymeep · 실행 python cavity_ldos.py (약 6.6 min, 단일 코어)

공식 문서와 다음 글

]]>jin-castleMeep Example 13 · 회전 대칭으로 3D를 계산하기 — cylindrical 좌표, m 급수, on/off-axis 쌍극자, 디스크 방사2026-10-23T00:00:00+00:002026-10-23T00:00:00+00:00https://jin-castle.github.io/meep-examples/cylindrical-dipole1. 먼저 보기: 축에서 벗어난 점광원은 몇 번 계산해야 할까?

회전 대칭인 구조를 계산할 때도 source까지 항상 축 대칭인 것은 아닙니다. 축에서 0.5 µm 떨어진 점광원 하나를 표현하려면, 방위 차수 m을 바꾸어 여러 번 계산한 field를 합쳐야 합니다.

축에서 0.5 마이크로미터 떨어진 쌍극자의 m별 power와 부분합 패턴 오차 및 최종 방사 패턴
실제 계산에서 m = 0…8까지 포함했고 마지막 항의 power는 최대의 9.49 × 10⁻⁶입니다. φ = 0 단면의 정규화 패턴은 해석 cos²θ와 상대 L2 오차 0.63%로 맞았습니다.

부분합이 매번 좋아지는 것은 아닙니다. m = 0…2의 패턴 오차는 0.099였지만 m = 3을 더하면 0.141로 잠시 증가했습니다. 모양이 좋아 보이는 중간 결과에서 멈추지 말고, m별 power와 패턴을 함께 확인합니다. 다른 구조나 더 먼 source에서는 power가 한 번 작아진 뒤 다시 커질 수도 있습니다.

2. 먼저 예측하기: 회전 대칭 구조면 m = 0만 있으면 될까?

축 위에서 x 방향으로 진동하는 선편광 쌍극자를 표현하려면?
예측과 source 표현 비교하기

두 번째입니다. 구조가 회전 대칭이어도 x 방향은 방위각 φ에 따라 원통좌표의 r·φ 성분이 달라집니다. 이 예제는 m = +1과 −1에서 Er와 ±i Ep를 사용하고 두 field를 반씩 더합니다. 축 위의 z 방향 쌍극자는 m = 0 한 번으로 표현합니다.

3. 원리 이해하기: 방위각을 m으로 나누어 계산하기

구조가 φ에 무관하면 field를 E(r, φ, z) = Σ E_m(r, z) exp(imφ)로 쓸 수 있습니다. m 하나를 고르면 φ 미분은 im을 곱하는 것으로 바뀌고, Meep은 남은 r–z 단면을 계산합니다. 3D 공간의 효과를 버리는 것이 아니라 방위각 의존성을 별도로 표현하는 방법입니다.

설명용 도식: 회전 대칭 구조의 r-z 단면을 방위 차수별로 계산하고 field를 합산한다 zr m마다 한 run exp(imφ) 반영 r–z 단면 + 방위각 의존성 field 합산 → 방향별 패턴
설명용 도식입니다. 사각형은 회전 대칭 구조의 단면, 점은 source 위치의 예시입니다. 색과 화살표는 실제 수치 field가 아닙니다. 각 m의 계산 결과에 방위각 의존성을 반영해 필요한 field를 구성합니다.
source 또는 문제 필요한 표현
축 위 z 쌍극자 m = 0, Ez
축 위 x 쌍극자 m = +1과 −1, Er와 ±i Ep
축 밖 점광원 여러 m의 Fourier 급수
정해진 방위 차수의 고리 모드 해당 m 하나로 계산

패턴은 field를 더한 뒤 power를 구합니다. φ = 0 단면에서 m별 power만 더하면 항 사이의 간섭이 사라집니다. 반면 전체 방위각에 걸쳐 적분한 총 power는 서로 다른 m의 직교성 때문에 항별 power를 더할 수 있습니다. 이 예제는 m 항의 power가 최대값의 10⁻⁴ 아래인지로 급수 중단을 판단합니다.

이 중단 규칙은 여기의 진공 r₀ = 0.5 µm 예제에 대한 기준입니다. 더 먼 source나 구조가 있는 문제에서 처음으로 작은 항 하나를 발견했다고 이후의 모든 항이 작다고 보장할 수는 없습니다.

계산된 고리의 m=3 반지름 field에 방위각과 시간 위상을 반영해 복원한 회전 모드
실제로 계산한 Ez(r)에 exp[i(3φ−ωt)]를 적용한 위상 복원 애니메이션입니다. 새로운 시간영역 3D 시뮬레이션이 아닙니다. m = −3 성분을 함께 구성하면 정상파를 만들 수 있습니다.

고리 예제의 차원. 파트 C의 ring-cyl은 셀의 z 크기가 0입니다. 12편의 z로 무한한 2D 고리 문제를 다른 좌표로 푼 것으로, 유한 높이의 실제 3D ring을 검증한 것은 아닙니다. 반면 일반적인 cylindrical r–z 셀은 회전 대칭 3D 구조를 m별로 표현할 수 있습니다.

파트 D의 디스크는 굴절률 2.4, 반지름 1.2 µm이고 아래에 손실 없는 PEC ground plane이 있습니다. m = −1 하나의 ring source를 계산하며, 임의의 off-axis 점광원 전체를 계산한 결과는 아닙니다. ground plane 때문에 near2far 면은 위와 바깥 r만 포함하고 아래는 열려 있습니다.

4. 직접 실행하기: m 급수의 중단 기준만 엄격하게 하기

저장소를 내려받아 code/ 폴더에서 실행합니다. cylindrical_dipole.py와 같은 폴더의 blogfig.py가 모두 필요합니다. Meep 1.33.0 MPI 환경과 Python·NumPy·Matplotlib을 사용한 원본 기록은 MPI 4개 프로세스에서 약 7.6분입니다.

OMP_NUM_THREADS=1 mpirun -np 4 python cylindrical_dipole.py

먼저 원본 결과를 별도 폴더에 보관하세요. POWER_DECAY = 1e-4를 1e-5로만 바꾸고 같은 명령으로 다시 실행합니다. source 거리, 해상도, 나머지 파트의 설정은 그대로 둡니다.

파트 B 로그의 마지막 m, 마지막 항의 power 비율, 최종 패턴 오차를 비교합니다. 원본 m = 8의 비율은 이미 9.49e-6이므로 이 한 단계의 기준 변경만으로 마지막 m이 늘지 않을 수도 있습니다. 이를 미리 실패로 판단하지 말고 실제 종료 기록을 확인하세요. 새 측정값은 원본 0.63%와 구별해 기록합니다.

5. 결과 해석하기: 무엇이 일치했고 무엇이 남았을까?

원본 비교 실제 결과 해석 범위
축 위 z 쌍극자 vs sin²θ 상대 L2 0.43% φ = 0의 정규화 패턴
축 위 x 쌍극자 vs cos²θ 상대 L2 0.46% m = ±1 field 합산
축 밖 r₀ = 0.5 µm m = 0…8, 상대 L2 0.63% 이 진공 예제의 급수
고리 m = 3, 4, 5 주파수 12편과 약 0.02%, 0.07%, 0.10% 차이 같은 2D 문제의 좌표계 비교

고리 m = 5의 Q는 cylindrical에서 1627, 12편 Cartesian 해상도 20에서 2132였습니다. 주파수가 가깝다고 Q도 수렴했다고 볼 수 없습니다. 다른 해상도의 Cartesian 값 1675·1610이 cylindrical 쪽에 가깝지만, 이것만으로 차이의 원인을 계단 경계 하나로 확정하지는 않습니다.

ground plane 위 디스크에서 셀 반지름 6과 8 마이크로미터의 near flux와 far flux 차이 비교
파트 D의 실제 결과입니다. 셀 반지름을 6에서 8 µm로 늘리자 near–far 차이는 7.43%에서 6.41%로 줄었습니다. 아직 차이가 남아 far-field 총 power가 수렴했다고 할 수 없습니다.
셀 반지름 near flux far flux 상대 차이
6 µm 643.65 595.80 7.43%
8 µm 643.28 602.05 6.41%

near flux는 거의 유지되고 far flux가 증가했습니다. 이는 열린 면 바깥의 등가 전류가 잘리는 truncation 해석과 맞지만, 두 셀 크기만으로 참된 far-field 총 power를 확정하지는 못합니다. 7.43%는 광추출 효율이 아니라 두 power 측정의 불일치입니다.

6. 이해 확인하기

  1. 축 위 x 쌍극자에서 m = 0 한 번으로 충분하지 않은 이유와, 방향별 패턴을 합산하는 순서를 설명해 보세요.
  2. 디스크의 near–far 차이가 7.43%에서 6.41%로 줄었다면, far-field 총 power가 수렴했다고 말할 수 있나요?
두 질문의 답 확인하기
  1. x 방향의 원통좌표 성분은 φ에 의존하므로 m = +1과 −1이 필요합니다. 필요한 m들의 복소 field를 먼저 더하고 Poynting으로 패턴을 구해야 간섭을 보존합니다.
  2. 아닙니다. 열린 near2far 면의 절단 효과가 줄어드는 해석과 일치할 뿐, 차이가 여전히 남아 있습니다. 더 넓은 면과 추가 수렴 확인 없이 참된 총 power나 광추출 효율로 보고할 수 없습니다.

7. 참고 자료와 전체 코드

원본의 상세 물리식, m별 수치, 좌표계별 설정과 전체 실행 기록을 아래에 보관했습니다.

English summary

TL;DR (English)

원통좌표 계산의 hero 원본 그림
  • What: post 12’s ring was a 2D cross-section; real discs, rings, lenses and LED mesas are bodies of revolution. dimensions=mp.CYLINDRICAL solves them as one 2D (r, z) run per azimuthal order m, with fields ∝ exp(imφ). Four official examples: on-axis dipoles, an off-axis dipole as an m series, post 12’s ring as one radial run per m, and a disc on a ground plane radiating through an open near2far surface.
  • Result: an on-axis z-dipole (m = 0) and x-dipole (m = +1 and −1) reproduce sin²θ and cos²θ to 0.43% and 0.46%. A dipole 0.5 µm off the axis needs m = 0…8 before the last term drops below 10⁻⁴ of the largest; the summed pattern matches cos²θ to 0.63%. The ring’s m = 3, 4, 5 modes land within 0.1% of post 12’s 2D frequencies. The disc radiates 7.43% less in the far field than through the near monitor, 6.41% with a larger radial cell.
  • Takeaway: a linearly polarized in-plane dipole is never m = 0. Every point off the axis is a sum over m, each m a separate run, and power (not field) per m decides when to stop. An open near2far surface on a ground plane loses the currents beyond its edge, and that, not the solver, is the near–far gap.
  • Code: full script at the bottom, ~7.6 min (mpirun -np 4).
배경·물리식·파라미터 자세히 보기

원본 §0 · 이 글에서 배우는 것

  • dimensions=mp.CYLINDRICAL과 m: φ 방향을 계산하지 않고 field를 exp(imφ)로 쓰는 법. 셀은 (r, 0, z)
  • 축 위 z 쌍극자는 m = 0, x 쌍극자는 m = +1과 −1의 합. 원편광 둘을 더해 선편광을 만든다
  • 축에서 떨어진 점광원 = m = 0, 1, 2, …의 Fourier 급수. 각 m은 독립된 run이고, m마다의 방사 power로 언제 멈출지 정한다
  • 12편 고리를 m 하나당 1D 반지름 run으로 다시 풀고 2D 그림을 exp(imφ)로 복원하기
  • 바닥이 무한한 ground plane이면 near2far 면이 닫히지 않는다. near flux와 far flux의 차이가 무엇을 뜻하는가

전제 지식: 10편의 near2far와 방사 패턴, 12편의 방위 차수 m. 공식 예제: Cylindrical coordinates 튜토리얼 · antenna in cylindrical coordinates · 스크립트 dipole_in_vacuum_cyl_on_axis.py · dipole_in_vacuum_cyl_off_axis.py · ring-cyl.py · disc_radiation_pattern.py. 이전 글: 12 · 빛을 가두는 고리 · 다음 글: 14 · 박막 속 점광원, 공기로 나오는 몫

원본 §1 · 무엇을 알고 싶은가

12편 끝 질문이었다. 고리는 2D 단면이었지만 실제 마이크로디스크, 렌즈, LED 메사는 축을 중심으로 돌려 만든 3D 구조다. 이런 구조를 3D 셀로 풀면 격자가 세제곱으로 늘어난다. 구조가 φ에 무관하면 field의 φ 의존성은 exp(imφ)의 합으로 쓸 수 있고, m이 정해지면 남는 것은 (r, z) 두 좌표뿐이다. 3D 문제가 m마다 2D 문제 하나로 바뀐다. 질문은 세 가지다. 축 위의 쌍극자는 어떤 m인가. 축에서 떨어진 점광원은 m을 몇 개 더해야 하는가. 그 결과는 3D와, 그리고 12편의 2D 고리와 맞는가.

어디에 쓰이는가

축 대칭은 발광·공진·집광 소자의 기본 형태다. cylindrical 좌표는 이런 소자를 3D 대신 2D 비용으로 계산하게 해 준다.

응용 이 글의 어떤 것을 쓰는가 그 다음에 필요한 것
LED·OLED·micro-LED 메사의 광추출 축 위 쌍극자(m = ±1), 축 밖 쌍극자의 m 급수, 열린 near2far 면 14편 광추출 효율
microdisk·microring 레이저, 바이오센서 방위 차수 m = whispering-gallery 차수, m마다 1D run 12편과 비교, 26편 결함 공진기
축 대칭 렌즈·zone plate·나노안테나 m = ±1 원편광 입사, 축 대칭 far field 16편 zone plate
광섬유 단면, 원형 격자 결합기 원통 도파 모드(m), r 방향 PML —

원본 §2 · 물리 한 페이지

구조가 φ에 무관하면 Maxwell 방정식의 φ 미분은 field에 $im$을 곱하는 것으로 바뀐다. field를 $\mathbf E(r,\phi,z)=\sum_m \mathbf E_m(r,z)\,e^{im\phi}$로 쓰면 m마다 독립된 (r, z) 문제가 된다. Meep은 m 하나를 받아 그 문제 하나를 푼다.

\[\mathbf E(r,\phi,z)=\sum_{m}\mathbf E_m(r,z)\,e^{im\phi},\qquad \hat x=\tfrac12\big[e^{i\phi}(\hat r+i\hat\phi)+e^{-i\phi}(\hat r-i\hat\phi)\big],\qquad P=\sum_m P_m\]

축 위에서 z 방향 쌍극자는 φ에 무관하므로 m = 0이다. x 방향 쌍극자는 φ를 따라 방향이 돌기 때문에 m = 0이 아니다. 가운데 식처럼 x 방향은 $e^{\pm i\phi}$를 가진 두 원편광($E_r\pm iE_\phi$)의 합이라 m = +1과 m = −1 두 run을 반씩 더한다. 축에서 r₀만큼 떨어진 점광원은 φ에서 델타 함수이고, 델타 함수의 Fourier 급수에는 모든 m이 들어간다. 다행히 m이 $k r_0$보다 커지면 그 항은 빛을 거의 내지 않는다. 그래서 m을 0부터 늘려 가며 각 m의 방사 power가 최대값의 10⁻⁴ 아래로 내려가면 멈춘다. 서로 다른 m의 field는 직교하므로 총 power는 m별 power의 합이다.

기호 뜻 코드 변수
$m$ 방위 차수, field ∝ $e^{im\phi}$ m=
$(r, z)$ 계산하는 단면. 셀은 (sr, 0, sz) cell_size
$r_0$ 점광원의 축 거리 R_SRC
$E_r\pm iE_\phi$ m = ±1 원편광 쌍극자 Er + Ep(amp ±1j)
$P_m$ m 항 하나의 방사 power m_flux
near / far 가까운 monitor flux / 먼 반구 적분 f_near, f_far

가정과 유효 범위: 파트 A·B는 진공, 파장 1 µm, 해상도 50. 파트 C는 12편의 고리(n 3.4, a = 1 µm)를 2D 대신 축 대칭 3D로 본 것이 아니라 같은 2D 문제를 다른 좌표로 푼 것이다. ring-cyl의 셀은 z 방향 크기가 0이라 z로 무한한 원기둥이다. 파트 D는 n 2.4 디스크, 바닥은 완전도체 ground plane이고 m = −1 하나(ring source)만 계산한다.

결과 보기 전에 맞춰보기

물리량 내 예측 근거
축 위 z 쌍극자 vs sin²θ 1% 안 노트 0.43%
축 위 x 쌍극자(m = ±1) vs cos²θ 1% 안 노트 0.46%
r₀ = 0.5 µm 점광원에 필요한 m 7~9 $k r_0=\pi$, 노트 m = 8
m 급수 패턴 오차의 감소 단조 감소 항을 더할수록 정확해진다
ring-cyl m = 3/4/5 vs 12편 2D 주파수 0.2% 안 같은 문제, 다른 좌표
ring-cyl Q(m = 5) vs 12편 2D(res 20) 비슷하다 같은 물리
디스크 near vs far flux 7% 차이 노트 7.42%, 공식 7.43%
반지름 셀 6 → 8 µm 차이가 준다 열린 면의 truncation이면

판정 기준: A가 5% 넘게 어긋나면 x 쌍극자의 $E_\phi$ 위상이나 m 부호를 의심한다. B에서 m을 다 더해도 오차가 1% 아래로 안 내려가면 −m 항(음의 주파수 field의 켤레)을 빠뜨린 것이다. D의 차이가 셀을 키워도 그대로면 truncation이 아니라 다른 원인이다.

원본 §3 · 시뮬레이션 설계도

파트 D의 cylindrical (r, z) 셀. 왼쪽 끝이 r = 0(축)이다. 회색 블록이 n 2.4 디스크(반지름 1.2 µm), 빨간 점이 r = 0.6 µm의 Er ring source, 파란 선이 flux monitor와
파트 D의 cylindrical (r, z) 셀. 왼쪽 끝이 r = 0(축)이다. 회색 블록이 n 2.4 디스크(반지름 1.2 µm), 빨간 점이 r = 0.6 µm의 Er ring source, 파란 선이 flux monitor와 near2far 면(위와 바깥 r). 아래 경계에는 PML이 없어 완전도체 ground plane이다. 녹색 빗금은 r 방향과 위쪽 PML, 파란 빗금은 대표 DFT field 영역이다. plot2D는 cylindrical 셀에서도 축 이름을 x, y로 쓰므로 x가 r, y가 z다. 동그라미 숫자는 §4의 단계 번호다.
파트 A·B의 (r, z) 셀. 진공, 사방 PML 1 µm(축 쪽 제외). 쌍극자는 축 위(A) 또는 r = 0.5 µm(B). near2far 면은 위, 바깥 r, 아래(weight −1)의 세 조각이다. 축은 경계가 아니라 대칭
파트 A·B의 (r, z) 셀. 진공, 사방 PML 1 µm(축 쪽 제외). 쌍극자는 축 위(A) 또는 r = 0.5 µm(B). near2far 면은 위, 바깥 r, 아래(weight −1)의 세 조각이다. 축은 경계가 아니라 대칭축이라 면이 필요 없다. 이 그림은 monitor를 붙이기 전의 셀이라 near2far 면은 그려지지 않았다.
파라미터 값 왜 이 값인가 바꾸면
A·B 셀 r 2 + PML 1, z 4 + PML 2 공식 값 near2far 면이 PML에 닿으면 안 된다
A·B 해상도 50 공식 값 Er source offset 1.5/res도 같이 바뀐다
A x 쌍극자 Er + Ep(±1j), m = ±1, r = 1.5/res 원편광 둘의 합. r = 0의 Er은 버그(meep #2704) m = 0으로 두면 x 쌍극자가 아니다
B source Er at r₀ = 0.5, +f와 −f 두 source +f가 +m, −f의 켤레가 −m 항 −f를 빼면 −m 항이 없다
B 종료 기준 m 항 power / 최대 < 10⁻⁴ 공식 값 너무 느슨하면 14편의 함정(되튐)
C 고리 n 3.4, R 1, w 1, PML 32, res 20 공식 ring-cyl.py 셀이 r 한 줄이라 PML이 두꺼워도 싸다
D 디스크 n 2.4, R 1.2, t = 0.7λ/n, res 100 공식 값 t를 바꾸면 패턴의 lobe가 바뀐다
D 반지름 셀 6 µm(공식), 8 µm truncation 확인 셀이 클수록 열린 면이 덜 잃는다
source 파형과 스펙트럼(1000 nm, fwidth 0.1 fcen). 모든 파트가 같은 상대 대역폭을 쓴다.
source 파형과 스펙트럼(1000 nm, fwidth 0.1 fcen). 모든 파트가 같은 상대 대역폭을 쓴다.

강의 노트북과의 차이: 강의 범위 밖이다. 10_sources의 노트들은 네 예제를 각각 따로 재현했다. 이 글은 한 스크립트에서 네 예제를 돌리고, B에서는 m 항을 하나 더할 때마다 패턴 오차를 재서 급수가 어떻게 수렴하는지 보이며, C에서는 12편 2D 결과와 같은 표에 올린다.

원본 코드 단계별 설명

원본 §4 · 코드 따라가기

읽는 순서: 단위·파라미터 → 재료·구조 → source → Simulation·경계 → monitor → 실행·종료 → 후처리. 이번 글의 새 요소는 ④의 dimensions=mp.CYLINDRICAL, m=과 ⑦의 m 합산이다.

① 단위와 파라미터 — 어떤 숫자를 고정하는가

WL, RES_D, PML_D = 1.0, 50, 1.0
SR_D, SZ_D = 2.0, 4.0                       # near2far box: r 0..2, z -2..2
R_FF, NPTS = 1e6 * WL, 50                   # far-field radius and polar samples
THETA = np.linspace(0, 0.5 * np.pi, NPTS)   # 0 = +z (pole), pi/2 = +r (equator), in the phi = 0 plane
POWER_DECAY = 1e-4                          # stop the m series when the last term is this small
  • 무엇: 공식 값. 각도는 +z에서 잰 극각이고 φ = 0 평면의 단면이다.
  • 왜: cylindrical 셀에서는 x가 r, z가 z다. y 크기는 항상 0이다.
  • 틀리면: 셀을 (sr, sz, 0)처럼 3D 습관으로 쓰면 z 크기 0의 다른 문제가 된다(파트 C는 일부러 그렇게 쓴다).

② 재료와 구조 — r ≥ 0 반쪽만 그린다

mp.Block(material=mp.Medium(index=N_DISC), center=mp.Vector3(0.5 * DISC_R, 0, -0.5 * sz + 0.5 * DISC_T),
         size=mp.Vector3(DISC_R, mp.inf, DISC_T))                                         # D: a disc = a block from r 0 to R
mp.Block(center=mp.Vector3(R_IN + 0.5 * W), size=mp.Vector3(W, mp.inf, mp.inf), material=mp.Medium(index=N_RING))   # C: a ring = a block from r 1 to 2
  • 무엇: 디스크는 r = 0부터 R까지의 블록, 고리는 r = 1부터 2까지의 블록이다. φ 방향 크기는 mp.inf.
  • 왜: (r, z) 단면에서 축 대칭 물체는 직사각형이다. 12편처럼 원기둥 두 개를 덮어쓸 필요가 없다.
  • 틀리면: 블록 center를 r = 0에 두고 size를 2R로 주면 음의 r 쪽은 셀 밖이라 버려진다. 결과는 같지만 의도가 흐려진다.

③ Source — m에 따라 source가 다르다

mp.Source(gs(FREQ), component=mp.Ez, center=mp.Vector3())                              # A: z-dipole on the axis, m = 0
[mp.Source(gs(FREQ), component=mp.Er, center=mp.Vector3(r_off)),                       # A: x-dipole = Er + (+-i) Ep, run with m = +1 and m = -1
 mp.Source(gs(FREQ), component=mp.Ep, center=mp.Vector3(r_off), amplitude=1j if m == 1 else -1j)]
[mp.Source(gs(FREQ), component=mp.Er, center=mp.Vector3(R_SRC)),                       # B: off-axis, +f gives the +m term ...
 mp.Source(gs(-FREQ), component=mp.Er, center=mp.Vector3(R_SRC))]                      # ... -f gives the -m term after conjugation
  • 무엇: 축 위 z 쌍극자는 Ez 하나. x 쌍극자는 m = ±1 run마다 Er과 ±i Ep의 쌍. 축 밖 점광원은 m마다 +f와 −f 두 source.
  • 왜: 세 번째 줄의 요령은 $e^{-im\phi}$ 항을 따로 돌리지 않으려는 것이다. 음의 주파수 field의 켤레가 −m 항과 같아서 run 하나로 ±m을 얻는다.
  • 틀리면: x 쌍극자를 m = 0의 Er 하나로 두면 축 대칭 방사(ring dipole)가 나오고 cos²θ와 전혀 다르다. 선편광은 m = 0이 아니다.

④ Simulation과 경계 — 축은 경계가 아니다

mp.Simulation(resolution=RES_D, cell_size=mp.Vector3(SR_D + PML_D, 0, SZ_D + 2 * PML_D), dimensions=mp.CYLINDRICAL, m=m,
              boundary_layers=[mp.PML(thickness=PML_D)], sources=sources, force_complex_fields=True)
boundary_layers=[mp.PML(PML_DISC, direction=mp.R), mp.PML(PML_DISC, direction=mp.Z, side=mp.High)]   # D: no PML at the bottom -> ground plane
  • 무엇: dimensions=mp.CYLINDRICAL과 m. PML은 r 바깥과 z 양쪽에 붙고 축(r = 0)에는 붙지 않는다. 파트 D는 아래에 PML이 없어 그 벽이 ground plane이다.
  • 왜: m ≠ 0이면 field가 복소수이므로 force_complex_fields=True. 11편과 같은 규칙으로 PML을 두지 않은 셀 벽은 완전도체다.
  • 틀리면: 10편에서는 k_point가 벽을 주기 경계로 바꿔 거울이 사라졌다. cylindrical에는 k_point가 없으므로 바닥 벽이 그대로 거울이다.

⑤ Monitor — near2far 면은 축을 닫지 않는다

mp.FluxRegion(center=mp.Vector3(0.5 * sr, 0, 0.5 * sz), size=mp.Vector3(sr, 0, 0))                  # top
mp.FluxRegion(center=mp.Vector3(sr, 0, 0), size=mp.Vector3(0, 0, sz))                                 # outer r
mp.FluxRegion(center=mp.Vector3(0.5 * sr, 0, -0.5 * sz), size=mp.Vector3(sr, 0, 0), weight=-1.0)     # bottom (A, B only)
ff = sim.get_farfield(n2f, mp.Vector3(R_FF * math.sin(th), 0, R_FF * math.cos(th)), GREENCYL_TOL)
  • 무엇: A·B는 위·바깥·아래 세 조각, D는 위·바깥 두 조각(아래는 ground plane이라 둘 수 없다). far field는 φ = 0 평면의 (r, z) 점에서 구한다.
  • 왜: 축은 대칭축이라 닫을 면이 없다. 회전하면 위·아래 원판과 옆 원통이 닫힌 면이 된다. GREENCYL_TOL은 φ 방향 적분의 허용 오차다.
  • 틀리면: D처럼 아래가 열려 있으면 ground plane 위 바깥 r 너머의 등가 전류가 빠진다. 이것이 §5의 near–far 차이다.

⑥ 실행 — m마다 run 하나

m = 0
while True:
    sim = dipole_sim(m, src); ...; sim.run(until_after_sources=mp.stop_when_fields_decayed(20, mp.Er, mp.Vector3(R_SRC), 1e-6))
    if m > 0 and P_m / P_max < POWER_DECAY:
        break
    m += 1
  • 무엇: m을 0부터 늘려 가며 run을 반복한다. 각 run은 독립이라 병렬로 돌려도 된다.
  • 왜: 필요한 m의 수는 $k r_0$로 어림된다. r₀ = 0.5 µm, k = 2π/µm이면 $kr_0\approx3.1$이고, power는 m = 5 근처부터 급히 준다.
  • 틀리면: 공식 코드의 종료 조건은 “처음으로 작아진 m”이다. 축에서 먼 점광원이나 구조가 있는 셀에서는 power가 줄다가 다시 커질 수 있다(10_sources Point Dipole CYL: r 3.5 µm에서 m 32의 0.5%가 m 41에서 38%로). 14편에서 다룬다.

⑦ 후처리 — field를 더하고 power를 잰다

e_tot += ep; h_tot += hp                         # +m term (exp(i m phi) = 1 at phi = 0)
if m > 0:
    e_tot += np.conj(em); h_tot += np.conj(hm)   # -m term from the negative-frequency run
pattern = radial_flux(e_tot, h_tot)              # |Re(E x H*)| on the far-field arc
P_m = total_flux(radial_flux(ep, hp))            # power of this m alone: decides when to stop
  • 무엇: φ = 0에서 field를 m에 대해 더하고 Poynting으로 패턴을 만든다. 종료 판단은 m 항 하나의 power로 한다.
  • 왜: 패턴은 field의 합이어야 간섭이 들어간다. 총 power는 m끼리 직교하므로 power의 합으로도 같다.
  • 틀리면: 패턴을 m별 power의 합으로 만들면 간섭이 빠져 φ 의존성이 없는 평균 패턴이 나온다. x 쌍극자의 cos²θ는 간섭의 결과다.

함정: cylindrical 셀의 get_array와 get_dft_array는 이 Meep 버전에서 (z, r) 순서로 돌려준다(11편). 2D처럼 전치하면 그림이 뒤집힌다. 이 글의 스크립트는 기대 크기와 비교해 방향을 맞추는 orient_rz를 쓴다.

원본 결과·검증 표·오류 진단·추가 탐구

원본 §5 · 결과

파트 A. 축 위 쌍극자의 φ = 0 단면 패턴(0°가 +z). 왼쪽: z 쌍극자, m = 0 한 run. 오른쪽: x 쌍극자, m = +1과 −1 두 run을 반씩 더한 것.
파트 A. 축 위 쌍극자의 φ = 0 단면 패턴(0°가 +z). 왼쪽: z 쌍극자, m = 0 한 run. 오른쪽: x 쌍극자, m = +1과 −1 두 run을 반씩 더한 것.
쌍극자 m 해석 패턴 상대 L2
z, 축 위 0 sin²θ 0.43%
x, 축 위 +1, −1 cos²θ 0.46%
파트 B. r₀ = 0.5 µm의 x 쌍극자. 왼쪽: m 항 하나의 방사 power(최대로 나눔). 가운데: m을 하나씩 더할 때마다 잰 패턴 오차. 오른쪽: m = 0…8을 다 더한 패턴과 cos²θ.
파트 B. r₀ = 0.5 µm의 x 쌍극자. 왼쪽: m 항 하나의 방사 power(최대로 나눔). 가운데: m을 하나씩 더할 때마다 잰 패턴 오차. 오른쪽: m = 0…8을 다 더한 패턴과 cos²θ.
m 0 1 2 3 4 5 6 7 8
$P_m/P_{\max}$ 1.00 0.94 1.00 0.64 0.18 2.8e-2 2.8e-3 1.9e-4 9.5e-6
0…m 합의 패턴 오차 0.589 0.409 0.099 0.141 0.030 0.0087 0.0064 0.0064 0.0063
파트 C. 12편의 고리를 m마다 1D 반지름 run으로. 위: Ez(r)과 고리 위치(회색). 아래: Re[Ez(r)e^imφ]로 복원한 x–y 그림. 부호 lobe가 2m개다.
파트 C. 12편의 고리를 m마다 1D 반지름 run으로. 위: Ez(r)과 고리 위치(회색). 아래: Re[Ez(r)e^{imφ}]로 복원한 x–y 그림. 부호 lobe가 2m개다.
m f (cylindrical) Q (cylindrical) f (12편 2D, res 20) Q (12편) Δf/f
3 0.11821 77 0.11818 79 +0.02%
4 0.14746 343 0.14736 342 +0.07%
5 0.17582 1627 0.17564 2132 +0.10%
파트 D. 왼쪽: ground plane 위 디스크의 far-field 패턴(두 셀 크기). 가운데: near monitor flux와 far 반구 적분. 오른쪽: log|Er|의 (r, z) 분포. 흰 사각형이 디스크.
파트 D. 왼쪽: ground plane 위 디스크의 far-field 패턴(두 셀 크기). 가운데: near monitor flux와 far 반구 적분. 오른쪽: log|Er|의 (r, z) 분포. 흰 사각형이 디스크.
반지름 셀 near flux far flux 차이
6 µm (공식) 643.65 595.80 7.43% (공식 문서 7.43%)
8 µm 643.28 602.05 6.41%

예측과 비교

물리량 내 예측 (§2) 시뮬레이션 판정
z 쌍극자 vs sin²θ 1% 안 0.43% ✅
x 쌍극자(m = ±1) vs cos²θ 1% 안 0.46% ✅
r₀ = 0.5 µm에 필요한 m 7~9 8 ✅
m 급수 오차 감소 단조 m = 2 → 3에서 0.099 → 0.141로 증가 후 감소 ❌
ring-cyl vs 12편 주파수 0.2% 안 0.1% ✅
ring-cyl Q(m = 5) vs 12편 비슷 1627 vs 2132 ❌
디스크 near vs far 7% 7.43% ✅
셀 6 → 8 µm 차이 감소 6.41% ✅

여덟 예측 중 여섯이 맞았고 둘이 빗나갔다. 첫째, m 급수의 오차는 단조로 줄지 않았다. m = 0…2까지 더한 패턴(오차 0.099)이 m = 3을 더한 패턴(0.141)보다 cos²θ에 가깝다. 급수의 부분합은 해석 패턴에 한 방향으로 다가가지 않는다. m = 3 항이 아직 큰 power(0.64)를 가진 채 더해져 일시적으로 모양을 흔들고, m = 4·5가 더해진 뒤에야 맞춰진다. 그래서 “오차가 작아 보이는 중간 m에서 멈추기”는 안 되고 각 m의 power로 멈춰야 한다. 둘째, 고리의 m = 5 Q가 cylindrical에서 1627, 12편 2D(res 20)에서 2132로 30% 다르다. 그런데 12편의 2D는 res 10에서 1675, res 30에서 1610이었다. 원을 계단으로 자르지 않는 cylindrical 값은 res 10·30의 2D 값과 같은 쪽이고, 튀었던 것은 2D res 20이다. 12편에서 Q가 해상도에 비단조라고 적은 이유가 계단 경계라는 해석과 맞는다. 주파수는 세 모드 모두 0.1% 안에서 같다. 디스크의 near–far 차이는 셀 6 µm에서 공식 문서와 같은 7.43%였고 8 µm에서 6.41%로 줄었다. 열린 면이 ground plane 위 셀 바깥의 등가 전류를 잃는다는 해석과 맞는다. near flux는 셀 크기에 거의 그대로(643.65 → 643.28)라서, 줄어든 차이는 far flux 쪽이 늘어난 것이다.

수렴성

변수 값 결과 비고
B: 포함한 m 0…4 / 0…5 / 0…8 오차 0.030 / 0.0087 / 0.0063 m = 6 이후 오차는 해상도가 정한다
C: 좌표계 2D Cartesian(12편, res 10/20/30) vs cylindrical(res 20) Q(m = 5) 1675/2132/1610 vs 1627 계단 경계가 없는 cylindrical이 res 10·30 쪽과 같다
D: 반지름 셀 6 / 8 µm 7.43% / 6.41% 차이가 셀 크기를 따라가면 truncation

주장할 수 있는 것 / 없는 것

  • 할 수 있는 것: 진공에서 축 위 쌍극자의 패턴은 m = 0(z) 또는 m = ±1(x)로 0.5% 안에서 맞는다. 축에서 0.5 µm 떨어진 x 쌍극자는 m = 0…8의 합으로 0.6% 안에서 맞는다. 12편 고리의 주파수는 cylindrical 좌표와 2D Cartesian이 0.1% 안에서 같다. ground plane 위 디스크의 near–far 차이는 반지름 셀을 키우면 줄어드는 truncation이다.
  • 할 수 없는 것: 축에서 먼 점광원이나 구조가 있는 셀에서 “power가 처음 10⁻⁴ 아래로 내려간 m”이 급수의 끝이라는 것(14편의 반례). 디스크의 진짜 far-field 총 power(열린 면 때문에 모른다). 2D Cartesian의 Q가 해상도마다 다른 이유를 staircase 하나로 확정하는 것(이 글은 일치하는 쪽을 보였을 뿐이다).

원본 §6 · 흔한 실수

증상 원인 고치는 법
x 쌍극자 패턴이 축 대칭 m = 0의 Er 하나로 둠 m = +1과 −1, 각각 Er + (±i)Ep
Er source에서 field가 발산 r = 0에 정확히 둠(meep #2704) 1.5/res만큼 비킨다
m을 다 더해도 오차 30% −m 항(−f 켤레)을 빼먹음 m > 0에서 conj(minus field)를 더한다
패턴에 간섭이 없음 m별 power를 더함 패턴은 field를 더하고, power는 종료 판단에만
2D 그림이 뒤집힘 cylindrical 배열은 (z, r) 기대 크기로 방향 확인
디스크 near·far가 7% 다름 열린 near2far 면 셀을 키워 차이가 주는지 확인
바닥 거울이 사라짐 아래에도 PML ground plane 쪽은 PML 없이

원본 §7 · 직접 해보기

바꿀 것 예상 변화 확인할 수치
B의 r₀ 0.5 → 1.5 µm 필요한 m이 약 3배(kr₀에 비례) 마지막 m, 각 m power의 되튐
B를 y 쌍극자(Ep)로 패턴이 상수 상대 L2 vs 1
C에서 m = 2 대역 0.10~0.20 밖, 낮은 Q Harminv 결과
D의 반지름 셀 12 µm 차이가 더 준다 near·far 차이
D의 디스크 두께 0.7λ/n → 0.5λ/n lobe가 바뀐다 패턴
code/cylindrical_dipole.py 전체 (클릭하여 펼치기) 
"""Meep Example 13 - Computing 3D with rotational symmetry: cylindrical coordinates and the m series.

Post 12's ring was a 2D cross-section. A real disc or ring is a body of revolution, and Meep's
dimensions=mp.CYLINDRICAL solves it as one 2D (r, z) run per azimuthal order m, with fields ~ exp(i m phi).
  A. On-axis dipoles in vacuum (official dipole_in_vacuum_cyl_on_axis.py): a z-dipole is m = 0 (Ez);
     an x-dipole is NOT m = 0 but the sum of m = +1 and m = -1 (Er + i Ep, Er - i Ep). Far-field
     patterns vs the analytic cos^2(theta) and sin^2(theta).
  B. An off-axis x-dipole at r = 0.5 um (official dipole_in_vacuum_cyl_off_axis.py): a point away from
     the axis is a Fourier series over m = 0, 1, 2, ... The series is summed until the power of the last
     m drops below 1e-4 of the largest; the pattern is checked after every added m.
  C. The ring of post 12 in cylindrical coordinates (official ring-cyl.py): one 1D radial run per m.
     Frequencies and Q compared with post 12's 2D Cartesian values; the m = 3 field rebuilt in the
     x-y plane from Ez(r) exp(i m phi).
  D. A dielectric disc on a ground plane (official disc_radiation_pattern.py): a ring source (m = -1),
     near flux vs far-field flux; the 7 % gap comes from the open near2far surface, checked by
     enlarging the radial cell.
MPI-safe: collective calls on every rank, figures on the master only.

Run:  mpirun -np 4 python cylindrical_dipole.py     (~6 min)
Out:  00_source.png, 01_layout.png, 02_layout_dipole.png, 03_on_axis.png, 04_off_axis.png, 05_ring_cyl.png,
      06_disc.png, 07_anim_m3.gif, result.json   (-> ../assets/13/)
"""
import cmath
import json
import math
import os
import sys
import time

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib import animation
import meep as mp

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from blogfig import Label, annotated_layout, source_figure   # noqa: E402

HERE = os.path.dirname(os.path.abspath(__file__))
OUT = os.path.join(HERE, "..", "assets", "13")
os.makedirs(OUT, exist_ok=True)
MASTER = mp.am_master()
t_all = time.time()


def say(*a):
    if MASTER:
        print(*a, flush=True)


def rel_l2(a, b):
    return float(np.linalg.norm(np.asarray(a) - np.asarray(b)) / np.linalg.norm(np.asarray(b)))


def orient_rz(arr, nr):
    """Cylindrical get_array/get_dft_array return (z, r) in this Meep version; return (r, z) whatever the order."""
    arr = np.asarray(arr)
    if arr.ndim == 2 and abs(arr.shape[1] - nr) < abs(arr.shape[0] - nr):
        return arr.T
    return arr


# ---------------------------------------------------------------- (1) parameters shared by A and B (official values, um)
WL = 1.0
FREQ = 1 / WL
RES_D = 50
PML_D = 1.0
SR_D, SZ_D = 2.0, 4.0                       # near2far box: r 0..2, z -2..2
R_FF = 1e6 * WL
NPTS = 50
THETA = np.linspace(0, 0.5 * np.pi, NPTS)   # 0 = +z (pole), pi/2 = +r (equator), in the phi = 0 plane
GREENCYL_TOL = 1e-6
POWER_DECAY = 1e-4


def n2f_regions(sr, sz):
    return [mp.FluxRegion(center=mp.Vector3(0.5 * sr, 0, 0.5 * sz), size=mp.Vector3(sr, 0, 0)),
            mp.FluxRegion(center=mp.Vector3(sr, 0, 0), size=mp.Vector3(0, 0, sz)),
            mp.FluxRegion(center=mp.Vector3(0.5 * sr, 0, -0.5 * sz), size=mp.Vector3(sr, 0, 0), weight=-1.0)]


def farfields(sim, n2f, tol=GREENCYL_TOL, theta=THETA, r_ff=R_FF):
    e = np.zeros((len(theta), 3), complex); h = np.zeros((len(theta), 3), complex)
    for n, th in enumerate(theta):
        ff = sim.get_farfield(n2f, mp.Vector3(r_ff * math.sin(th), 0, r_ff * math.cos(th)), tol)
        e[n] = ff[:3]; h[n] = ff[3:]
    return e, h


def radial_flux(e, h):
    fx = np.real(e[:, 1] * np.conj(h[:, 2]) - e[:, 2] * np.conj(h[:, 1]))
    fz = np.real(e[:, 0] * np.conj(h[:, 1]) - e[:, 1] * np.conj(h[:, 0]))
    return np.sqrt(fx ** 2 + fz ** 2)


def total_flux(pattern, theta=THETA, r_ff=R_FF):
    return float(2 * np.pi * r_ff ** 2 * np.trapezoid(pattern * np.sin(theta), theta))


def dipole_sim(m, sources):
    return mp.Simulation(resolution=RES_D, cell_size=mp.Vector3(SR_D + PML_D, 0, SZ_D + 2 * PML_D), dimensions=mp.CYLINDRICAL, m=m,
                         boundary_layers=[mp.PML(thickness=PML_D)], sources=sources, force_complex_fields=True)


# ================================================================ A. on-axis dipoles
t_a = time.time()
r_off = 1.5 / RES_D                          # an Er source exactly at r = 0 hits a known bug (meep issue 2704): offset by 1.5 px
gs = lambda f: mp.GaussianSource(f, fwidth=0.1 * abs(f))
on = {}
# z-dipole: m = 0, Ez on the axis
sim = dipole_sim(0, [mp.Source(gs(FREQ), component=mp.Ez, center=mp.Vector3())])
annotated_layout(sim, os.path.join(OUT, "02_layout_dipole.png"), dpml=PML_D, figsize=(5.4, 7.6), axis_step=1.0, unit="um",
                 title="parts A, B: cylindrical (r, z) cell; r = 0 is the left edge (the axis)",
                 params_text=f"wl={WL} um, res={RES_D}\nm = 0, +-1 (A)\nm = 0..8 (B)", params_xy=(0.15, 3.75), pml_xy=(0.15, -3.5), decay_point=None,
                 labels=[Label("dipole on the axis (A) or at r = 0.5 (B)", (0.03, 0.0), (0.4, 0.9), step=3, color="red"),
                         Label("near2far: top, outer r, bottom (weight -1)", (2.0, 1.0), (0.4, 2.6), step=5, color="blue"),
                         Label("vacuum: no geometry", (1.0, -1.0), (0.4, -1.4), step=2, color="black")])
n2f = sim.add_near2far(FREQ, 0, 1, *n2f_regions(SR_D, SZ_D))
sim.run(until_after_sources=mp.stop_when_fields_decayed(20, mp.Ez, mp.Vector3(), 1e-6))
on["z"] = farfields(sim, n2f); sim.reset_meep()
# x-dipole: m = +1 and m = -1, each Er + (+-i) Ep, combined with weight 1/2 and exp(+-i phi) at phi = 0
ex = np.zeros((NPTS, 3), complex); hx = np.zeros((NPTS, 3), complex)
for m in (+1, -1):
    src = [mp.Source(gs(FREQ), component=mp.Er, center=mp.Vector3(r_off)),
           mp.Source(gs(FREQ), component=mp.Ep, center=mp.Vector3(r_off), amplitude=1j if m == 1 else -1j)]
    sim = dipole_sim(m, src)
    n2f = sim.add_near2far(FREQ, 0, 1, *n2f_regions(SR_D, SZ_D))
    sim.run(until_after_sources=mp.stop_when_fields_decayed(20, mp.Er, mp.Vector3(r_off), 1e-6))
    e, h = farfields(sim, n2f); sim.reset_meep()
    ex += 0.5 * e; hx += 0.5 * h
on["x"] = (ex, hx)
pat_on = {k: radial_flux(*v) for k, v in on.items()}
an_on = {"x": np.cos(THETA) ** 2, "z": np.sin(THETA) ** 2}
err_on = {k: rel_l2(pat_on[k] / pat_on[k].max(), an_on[k]) for k in on}
say(f"A: on-axis z-dipole (m = 0) vs sin^2: rel L2 {err_on['z']:.4f}; x-dipole (m = +1 and -1) vs cos^2: {err_on['x']:.4f}; {time.time() - t_a:.0f} s")
if MASTER:
    source_figure(FREQ, 0.1 * FREQ, os.path.join(OUT, "00_source.png"), wl_scale=1000.0, wl_unit="nm", time_unit="um/c")

# ================================================================ B. off-axis x-dipole: the m series
t_b = time.time()
R_SRC = 0.5
e_tot = np.zeros((NPTS, 3), complex); h_tot = np.zeros((NPTS, 3), complex)
m_flux, m_err, flux_max = [], [], 0.0
m = 0
while True:
    src = [mp.Source(gs(FREQ), component=mp.Er, center=mp.Vector3(R_SRC)),
           mp.Source(gs(-FREQ), component=mp.Er, center=mp.Vector3(R_SRC))]          # +f gives the +m term, -f the -m term (conjugated)
    sim = dipole_sim(m, src)
    n2p = sim.add_near2far(FREQ, 0, 1, *n2f_regions(SR_D, SZ_D))
    n2m = sim.add_near2far(-FREQ, 0, 1, *n2f_regions(SR_D, SZ_D))
    sim.run(until_after_sources=mp.stop_when_fields_decayed(20, mp.Er, mp.Vector3(R_SRC), 1e-6))
    ep, hp = farfields(sim, n2p); em, hm = farfields(sim, n2m); sim.reset_meep()
    e_tot += ep; h_tot += hp                                   # exp(i m phi) = 1 at phi = 0
    if m > 0:
        e_tot += np.conj(em); h_tot += np.conj(hm)
    fl = total_flux(radial_flux(ep, hp))
    flux_max = max(flux_max, fl)
    p = radial_flux(e_tot, h_tot)
    m_flux.append(fl); m_err.append(rel_l2(p / p.max(), np.cos(THETA) ** 2))
    say(f"B: m = {m}: power of this m / max = {fl / flux_max:.2e}; pattern error after summing 0..{m}: {m_err[-1]:.4f}")
    if m > 0 and fl / flux_max < POWER_DECAY:
        break
    m += 1
pat_off = radial_flux(e_tot, h_tot)
say(f"B: off-axis x-dipole at r = {R_SRC}: stopped at m = {m}; final rel L2 vs cos^2 {m_err[-1]:.4f}; {time.time() - t_b:.0f} s")

# ================================================================ C. post 12's ring in cylindrical coordinates
t_c = time.time()
N_RING, W, R_IN, PAD, DPML_R = 3.4, 1.0, 1.0, 4.0, 32.0
SR_R = R_IN + W + PAD + DPML_R
RES_R = 20
FC, DFC = 0.15, 0.1
POST12 = {3: (0.11818, 79), 4: (0.14736, 342), 5: (0.17564, 2132)}     # 2D Cartesian, res 20 (post 12)
ring = {}


def ring_sim(m, f, df):
    return mp.Simulation(cell_size=mp.Vector3(SR_R, 0, 0), resolution=RES_R, dimensions=mp.CYLINDRICAL, m=m, boundary_layers=[mp.PML(DPML_R)],
                         geometry=[mp.Block(center=mp.Vector3(R_IN + 0.5 * W), size=mp.Vector3(W, mp.inf, mp.inf), material=mp.Medium(index=N_RING))],
                         sources=[mp.Source(mp.GaussianSource(f, fwidth=df), component=mp.Ez, center=mp.Vector3(R_IN + 0.1))])


for mm in (3, 4, 5):
    sim = ring_sim(mm, FC, DFC)
    hv = mp.Harminv(mp.Ez, mp.Vector3(R_IN + 0.1), FC, DFC)
    sim.run(mp.after_sources(hv), until_after_sources=200)
    modes = [md for md in hv.modes if md.Q > 0 and FC - 0.5 * DFC < md.freq < FC + 0.5 * DFC]
    md = max(modes, key=lambda x: abs(x.amp)); sim.reset_meep()
    f, Q = float(md.freq), float(md.Q)
    sim = ring_sim(mm, f, 0.01)
    dft = sim.add_dft_fields([mp.Ez], f, 0, 1, center=mp.Vector3(0.5 * (R_IN + W + PAD)), size=mp.Vector3(R_IN + W + PAD))
    sim.run(until_after_sources=mp.stop_when_fields_decayed(50, mp.Ez, mp.Vector3(R_IN + 0.1), 1e-6))
    ezr = np.squeeze(sim.get_dft_array(dft, mp.Ez, 0)); sim.reset_meep()
    ring[mm] = {"f": f, "Q": Q, "ez_r": ezr}
    say(f"C: m = {mm}: cylindrical f {f:.5f} Q {Q:.0f} | post 12 (2D, res 20): f {POST12[mm][0]:.5f} Q {POST12[mm][1]} -> df/f {(f - POST12[mm][0]) / POST12[mm][0]:+.2e}")
say(f"C done in {time.time() - t_c:.0f} s")

# ================================================================ D. disc on a ground plane, near vs far flux
t_d = time.time()
RES_DISC, PML_DISC, AIR = 100, 0.5, 1.0
DISC_R, N_DISC = 1.2, 2.4
DISC_T = 0.7 * WL / N_DISC
NPOL = 100
THETA_D = np.linspace(0, 0.5 * np.pi, NPOL)
disc = {}
for cell_r in (6.0, 8.0):
    sr = cell_r + PML_DISC; sz = DISC_T + AIR + PML_DISC
    src_pt = mp.Vector3(0.5 * DISC_R, 0, -0.5 * sz + 0.5 * DISC_T)
    sim = mp.Simulation(resolution=RES_DISC, cell_size=mp.Vector3(sr, 0, sz), dimensions=mp.CYLINDRICAL, m=-1,
                        boundary_layers=[mp.PML(PML_DISC, direction=mp.R), mp.PML(PML_DISC, direction=mp.Z, side=mp.High)],   # no PML at the bottom: PEC ground plane
                        sources=[mp.Source(mp.GaussianSource(FREQ, fwidth=0.1 * FREQ), component=mp.Er, center=src_pt)],
                        geometry=[mp.Block(material=mp.Medium(index=N_DISC), center=mp.Vector3(0.5 * DISC_R, 0, -0.5 * sz + 0.5 * DISC_T), size=mp.Vector3(DISC_R, mp.inf, DISC_T))])
    regs = [mp.FluxRegion(center=mp.Vector3(0.5 * cell_r, 0, 0.5 * sz - PML_DISC), size=mp.Vector3(cell_r, 0, 0)),
            mp.FluxRegion(center=mp.Vector3(cell_r, 0, 0.5 * sz - PML_DISC - 0.5 * (AIR + DISC_T)), size=mp.Vector3(0, 0, AIR + DISC_T))]
    flux = sim.add_flux(FREQ, 0, 1, *regs)
    n2f = sim.add_near2far(FREQ, 0, 1, *regs)
    dft = None
    if cell_r == 6.0:
        dft = sim.add_dft_fields([mp.Er], FREQ, 0, 1, center=mp.Vector3(0.5 * cell_r, 0, -0.5 * PML_DISC), size=mp.Vector3(cell_r, 0, sz - PML_DISC))
        annotated_layout(sim, os.path.join(OUT, "01_layout.png"), dpml=PML_DISC, figsize=(11, 3.8), axis_step=1.0, unit="um",
                         title="part D: disc (n = 2.4, R = 1.2 um) on a ground plane, cylindrical (r, z); bottom edge = PEC (no PML)",
                         params_text=f"wl={WL} um, res={RES_DISC}\nm = -1, t = {DISC_T:.3f} um", params_xy=(3.4, 0.33), pml_xy=(6.05, -0.6),
                         decay_point=(src_pt.x, src_pt.z), decay_text_xy=(1.5, -0.45),
                         labels=[Label("disc", (0.9, src_pt.z + 0.05), (1.5, -0.2), step=2, color="black"),
                                 Label("Er ring source at r = 0.6", (src_pt.x, src_pt.z), (1.5, 0.05), step=3, color="red"),
                                 Label("flux + near2far: top and outer r (open at the bottom)", (5.0, 0.5 * sz - PML_DISC), (3.4, -0.2), step=5, color="blue")])
    sim.run(until_after_sources=mp.stop_when_fields_decayed(50, mp.Er, src_pt, 1e-8))
    f_near = float(mp.get_fluxes(flux)[0])
    e, h = farfields(sim, n2f, tol=1e-8, theta=THETA_D)
    pat = radial_flux(e, h)
    f_far = total_flux(pat, theta=THETA_D)
    er = orient_rz(sim.get_dft_array(dft, mp.Er, 0), int(round(cell_r * RES_DISC))) if dft is not None else None
    sim.reset_meep()
    disc[cell_r] = {"near": f_near, "far": f_far, "gap": abs(f_near - f_far) / f_near, "pattern": pat, "er": er, "sz": sz}
    say(f"D: cell r {cell_r}: near flux {f_near:.4f}, far flux {f_far:.4f}, gap {100 * disc[cell_r]['gap']:.2f} %")
say(f"D done in {time.time() - t_d:.0f} s")

# ================================================================ figures (master only)
if MASTER:
    # A
    fig, ax = plt.subplots(1, 2, figsize=(10, 4.6), subplot_kw={"projection": "polar"})
    for a, k, lab in ((ax[0], "z", "z-dipole: m = 0 (Ez)  vs sin^2"), (ax[1], "x", "x-dipole: m = +1 and m = -1  vs cos^2")):
        a.plot(THETA, pat_on[k] / pat_on[k].max(), "b-", lw=1.6, label="Meep (cylindrical)")
        a.plot(THETA, an_on[k], "r--", lw=1.2, label="analytic")
        a.set_theta_zero_location("N"); a.set_theta_direction(-1); a.set_thetamin(0); a.set_thetamax(90); a.set_rmax(1.05)
        a.set_title(f"{lab}\nrel L2 {err_on[k]:.4f}", fontsize=9); a.legend(fontsize=7, loc="lower left")
    fig.suptitle("part A: on-axis dipoles (angle from +z, phi = 0 plane). A linearly polarized in-plane dipole is two m runs", fontsize=10)
    fig.tight_layout(); fig.savefig(os.path.join(OUT, "03_on_axis.png"), dpi=150); plt.close(fig)
    # B
    fig = plt.figure(figsize=(13, 4.4))
    ax = fig.add_subplot(1, 3, 1)
    ms = np.arange(len(m_flux))
    ax.semilogy(ms, np.array(m_flux) / max(m_flux), "o-", color="tab:blue"); ax.axhline(POWER_DECAY, color="crimson", ls="--", lw=1, label="stop: 1e-4 of the max")
    ax.set_xlabel("azimuthal order m"); ax.set_ylabel("far-field power of the m term / max"); ax.set_title(f"dipole at r = {R_SRC} um: how much each m radiates", fontsize=9); ax.grid(alpha=0.3, which="both"); ax.legend(fontsize=8)
    ax = fig.add_subplot(1, 3, 2)
    ax.semilogy(ms, m_err, "s-", color="tab:green"); ax.set_xlabel("m included up to"); ax.set_ylabel("rel L2 of the summed pattern vs cos^2"); ax.set_title("the pattern converges as m terms are added", fontsize=9); ax.grid(alpha=0.3, which="both")
    ax = fig.add_subplot(1, 3, 3, projection="polar")
    ax.plot(THETA, pat_off / pat_off.max(), "b-", lw=1.6, label=f"Meep, m = 0..{m}"); ax.plot(THETA, np.cos(THETA) ** 2, "r--", lw=1.2, label="cos^2")
    ax.set_theta_zero_location("N"); ax.set_theta_direction(-1); ax.set_thetamin(0); ax.set_thetamax(90); ax.set_rmax(1.05); ax.legend(fontsize=7, loc="lower left")
    ax.set_title(f"off-axis x-dipole: rel L2 {m_err[-1]:.4f}", fontsize=9)
    fig.suptitle("part B: a point away from the axis is a Fourier series over m; each m is one 2D (r, z) run", fontsize=10)
    fig.tight_layout(); fig.savefig(os.path.join(OUT, "04_off_axis.png"), dpi=150); plt.close(fig)
    # C: Ez(r) and the x-y reconstruction for m = 3, 4, 5
    rr = np.linspace(0, R_IN + W + PAD, len(ring[3]["ez_r"]))
    L = R_IN + W + 1.5
    xg = np.linspace(-L, L, 301); X, Y = np.meshgrid(xg, xg, indexing="ij"); RG = np.hypot(X, Y); PH = np.arctan2(Y, X)
    fig, ax = plt.subplots(2, 3, figsize=(12.5, 7.8), gridspec_kw={"height_ratios": [1, 1.5]})
    for k, mm in enumerate((3, 4, 5)):
        d = ring[mm]; ez = d["ez_r"] / np.max(np.abs(d["ez_r"]))
        ax[0, k].plot(rr, np.real(ez), "b-", label="Re"); ax[0, k].plot(rr, np.abs(ez), "k-", lw=0.8, label="|Ez|")
        ax[0, k].axvspan(R_IN, R_IN + W, color="gray", alpha=0.25); ax[0, k].set_xlabel("r [a]"); ax[0, k].set_title(f"m = {mm}: f = {d['f']:.4f}, Q = {d['Q']:.0f} (one 1D radial run)", fontsize=9)
        ax[0, k].grid(alpha=0.3); ax[0, k].legend(fontsize=7)
        field = np.real(np.interp(RG, rr, np.real(ez)) * np.cos(mm * PH) - np.interp(RG, rr, np.imag(ez)) * np.sin(mm * PH))
        field[RG > rr[-1]] = 0
        lim = np.max(np.abs(field))
        ax[1, k].imshow(field.T, extent=[-L, L, -L, L], origin="lower", cmap="RdBu", vmin=-lim, vmax=lim, aspect="equal")
        for rc in (R_IN, R_IN + W):
            ax[1, k].add_patch(plt.Circle((0, 0), rc, fill=False, color="k", lw=0.8))
        ax[1, k].set_title(f"Re[Ez(r) exp(i {mm} phi)]: {2 * mm} sign lobes; post 12: f {POST12[mm][0]:.4f}", fontsize=9); ax[1, k].set_xlabel("x [a]")
    ax[1, 0].set_ylabel("y [a]")
    fig.suptitle("part C: post 12's ring as one radial run per m; the 2D picture is rebuilt from exp(i m phi)", fontsize=10)
    fig.tight_layout(); fig.savefig(os.path.join(OUT, "05_ring_cyl.png"), dpi=150); plt.close(fig)
    # D
    fig = plt.figure(figsize=(13.5, 4.4))
    ax = fig.add_subplot(1, 3, 1, projection="polar")
    for cr, c in ((6.0, "tab:blue"), (8.0, "tab:orange")):
        p = disc[cr]["pattern"]; ax.plot(THETA_D, p / disc[6.0]["pattern"].max(), "-", color=c, lw=1.4, label=f"cell r {cr:.0f} um")
    ax.set_theta_zero_location("N"); ax.set_theta_direction(-1); ax.set_thetamin(0); ax.set_thetamax(90); ax.legend(fontsize=7, loc="lower left")
    ax.set_title("disc on a ground plane: far-field pattern", fontsize=9)
    ax = fig.add_subplot(1, 3, 2)
    idx = np.arange(2)
    ax.bar(idx - 0.2, [disc[c]["near"] for c in (6.0, 8.0)], width=0.4, color="tab:gray", label="near flux (monitor)")
    ax.bar(idx + 0.2, [disc[c]["far"] for c in (6.0, 8.0)], width=0.4, color="tab:blue", label="far flux (hemisphere integral)")
    for k, c in enumerate((6.0, 8.0)):
        ax.text(k, max(disc[c]["near"], disc[c]["far"]) * 1.02, f"gap {100 * disc[c]['gap']:.2f} %", ha="center", fontsize=8)
    ax.set_xticks(idx); ax.set_xticklabels(["cell r 6 um", "cell r 8 um"]); ax.set_ylabel("power (a.u.)"); ax.set_title("the open near2far surface misses currents on the ground plane", fontsize=9); ax.legend(fontsize=7, loc="lower right")
    ax = fig.add_subplot(1, 3, 3)
    er = disc[6.0]["er"]; sz = disc[6.0]["sz"]
    ax.imshow(np.log10(np.abs(er) + 1e-12).T, extent=[0, 6.0, -0.5 * sz, 0.5 * sz - PML_DISC], origin="lower", cmap="inferno", aspect="auto")
    ax.add_patch(plt.Rectangle((0, -0.5 * sz), DISC_R, DISC_T, fill=False, color="w", lw=1))
    ax.set_xlabel("r [um]"); ax.set_ylabel("z [um]"); ax.set_title("log10 |Er| at 1 um (r, z plane)", fontsize=9)
    fig.suptitle("part D: near vs far flux; the gap shrinks when the radial cell grows", fontsize=10)
    fig.tight_layout(); fig.savefig(os.path.join(OUT, "06_disc.png"), dpi=150); plt.close(fig)
    # GIF: m = 3 mode rotating: Re[Ez(r) exp(i (3 phi - w t))]
    d = ring[3]; ez = d["ez_r"] / np.max(np.abs(d["ez_r"]))
    Er_ = np.interp(RG, rr, np.real(ez)); Ei_ = np.interp(RG, rr, np.imag(ez)); amp = np.where(RG > rr[-1], 0, 1)
    fig_g, ax_g = plt.subplots(figsize=(4.8, 4.4))
    im = ax_g.imshow(np.zeros_like(RG).T, extent=[-L, L, -L, L], origin="lower", cmap="RdBu", vmin=-1, vmax=1, aspect="equal")
    for rc in (R_IN, R_IN + W):
        ax_g.add_patch(plt.Circle((0, 0), rc, fill=False, color="k", lw=0.8))
    ax_g.set_xlabel("x [a]"); ax_g.set_ylabel("y [a]"); ttl = ax_g.set_title("", fontsize=9); fig_g.tight_layout()
    NF = 36

    def upd(i):
        wt = 2 * np.pi * i / NF
        fld = amp * (Er_ * np.cos(3 * PH - wt) - Ei_ * np.sin(3 * PH - wt))
        im.set_data((fld / np.max(np.abs(fld))).T); ttl.set_text(f"m = 3 mode, Re[Ez(r) exp(i(3 phi - wt))], wt = {np.degrees(wt):.0f} deg")
        return im, ttl

    animation.FuncAnimation(fig_g, upd, frames=NF, blit=False).save(os.path.join(OUT, "07_anim_m3.gif"), writer=animation.PillowWriter(fps=12), dpi=75)
    plt.close(fig_g)
    with open(os.path.join(OUT, "result.json"), "w") as f_:
        json.dump({"A": {"err_z": err_on["z"], "err_x": err_on["x"]},
                   "B": {"r_src": R_SRC, "m_last": m, "m_flux_rel": (np.array(m_flux) / max(m_flux)).tolist(), "m_err": m_err},
                   "C": {str(k): {"f": v["f"], "Q": v["Q"], "post12_f": POST12[k][0], "post12_Q": POST12[k][1]} for k, v in ring.items()},
                   "D": {str(k): {"near": v["near"], "far": v["far"], "gap": v["gap"]} for k, v in disc.items()},
                   "wall_s_total": time.time() - t_all, "np": mp.count_processors(), "meep": mp.__version__}, f_, indent=2)
say(f"total {time.time() - t_all:.0f} s on {mp.count_processors()} process(es)")
원본 실행 기록과 재현 환경

§4의 발췌 코드와 달리 전체 코드에는 두 layout 그림, m 급수 수렴 그림, 고리의 x–y 복원, 디스크 field, GIF, result.json 기록이 들어 있다. MPI로 돌릴 수 있게 collective 호출(run, get_farfield, get_dft_array)은 모든 rank에서, 그림 저장은 master에서만 한다. 전체 코드와 helper: https://github.com/jin-castle/meep-examples/blob/main/code.

실행 결과 (2026-10-23 실행, mpirun -np 4):

A: on-axis z-dipole (m = 0) vs sin^2: rel L2 0.0043; x-dipole (m = +1 and -1) vs cos^2: 0.0046; 53 s
B: m = 0: power of this m / max = 1.00e+00; pattern error after summing 0..0: 0.5890
B: m = 1: power of this m / max = 9.36e-01; pattern error after summing 0..1: 0.4094
B: m = 2: power of this m / max = 1.00e+00; pattern error after summing 0..2: 0.0987
B: m = 3: power of this m / max = 6.36e-01; pattern error after summing 0..3: 0.1405
B: m = 4: power of this m / max = 1.80e-01; pattern error after summing 0..4: 0.0298
B: m = 5: power of this m / max = 2.79e-02; pattern error after summing 0..5: 0.0087
B: m = 6: power of this m / max = 2.78e-03; pattern error after summing 0..6: 0.0064
B: m = 7: power of this m / max = 1.90e-04; pattern error after summing 0..7: 0.0064
B: m = 8: power of this m / max = 9.49e-06; pattern error after summing 0..8: 0.0063
B: off-axis x-dipole at r = 0.5: stopped at m = 8; final rel L2 vs cos^2 0.0063; 139 s
C: m = 3: cylindrical f 0.11821 Q 77 | post 12 (2D, res 20): f 0.11818 Q 79 -> df/f +2.30e-04
C: m = 4: cylindrical f 0.14746 Q 343 | post 12 (2D, res 20): f 0.14736 Q 342 -> df/f +6.62e-04
C: m = 5: cylindrical f 0.17582 Q 1627 | post 12 (2D, res 20): f 0.17564 Q 2132 -> df/f +1.02e-03
D: cell r 6.0: near flux 643.6506, far flux 595.8024, gap 7.43 %
D: cell r 8.0: near flux 643.2784, far flux 602.0512, gap 6.41 %
total 457 s on 4 process(es)

재현 환경: meep 1.33.0 (MPI) · Python 3.11 · conda install -c conda-forge pymeep=*=mpi_mpich_* · 실행 mpirun -np 4 python cylindrical_dipole.py (약 7.6 min (mpirun -np 4))

공식 문서와 다음 글

]]>jin-castleMeep Example 10 · 점광원의 3D 방사 패턴 — Bloch 1D run 묶음과 PEC 거울의 image dipole2026-10-23T00:00:00+00:002026-10-23T00:00:00+00:00https://jin-castle.github.io/meep-examples/dipole-pattern-3d1. 먼저 보기: 점광원은 모든 방향으로 똑같이 빛날까?

01편의 2D 점원에서 한 걸음 나아가, 진동하는 축이 있는 3D 쌍극자를 봅니다. x 방향으로 진동하면 x축 방향은 어둡고, 그 축에 수직인 면에서는 고르게 빛납니다. 이를 큰 3D 셀 대신 방향별 1D 계산을 모아 재현할 수 있습니다.

240개 Bloch 1D 계산으로 재구성한 진공 x 쌍극자의 3D 방사 패턴과 해석해 비교
계산한 240개 방향에서 올바르게 환산한 패턴의 상대 L2 오차는 0.22%입니다. 아래 지도의 회색 띠는 계산하지 않은 각도이며, 빛이 나오지 않는 영역이라는 뜻이 아닙니다.

3D 패턴과 2D 그림을 구별하세요. 파트 A·C는 Bloch 1D run 묶음으로 3D Ex 쌍극자의 방향별 성분을 구합니다. 파트 B의 거울 애니메이션은 별도의 2D Ez 모델입니다. 모든 패턴 비교는 최대값으로 정규화한 모양이며 절대 방출 power나 directivity를 검증한 결과는 아닙니다.

2D Ez 쌍극자와 반대 부호의 image가 거울면에서 상쇄하는 펄스 전파
파트 B의 실제 2D 펄스입니다. 위쪽 source와 아래쪽 image가 y = 0에서 상쇄합니다. 위쪽 절반만 거울 위의 물리적 공간입니다.

2. 먼저 예측하기: 계산하지 않은 방향을 어떻게 읽을까?

방사 패턴 지도에서 약 72° 이상의 방향이 회색으로 비어 있다면?
예측과 계산 조건 비교하기

두 번째입니다. 파트 A는 sin θ > 0.95인 방향을 건너뜁니다. 거의 옆으로 진행하는 파는 z 방향 PML에 비스듬하게 들어가 흡수가 어려워집니다. 이 빈칸을 0으로 채워 해석해와 비교하면 물리적인 null과 누락된 데이터를 혼동합니다.

3. 원리 이해하기: 한 방향씩 계산하고, 거울은 image로 보기

점광원의 field를 평면파 성분으로 나누면, 횡방향 파수 k_point 하나가 나가는 방향 하나에 대응합니다. 각 방향에서 z축을 따라 계산하고, 얻은 flux를 S_r = S_z cos θ로 환산한 뒤 모읍니다. θ는 +z축으로부터 잰 각도입니다.

설명용 도식: z축만 계산하고 k_point로 비스듬한 전파 방향을 지정한다 +zθ k_point → 방향 1D 셀은 z만 계산 방향별 표본 → 환산 → 3D 패턴
설명용 도식입니다. 화살표는 수치 field가 아니라 하나의 평면파 방향을 나타냅니다. 방향을 바꿔 반복한 여러 1D run이 3D 패턴을 구성합니다.

cos θ는 단순히 z flux를 진행 방향으로 돌리는 투영만으로 정해지는 값이 아닙니다. 횡방향 파수 공간의 표본을 입체각당 power로 바꾸는 Jacobian까지 포함합니다. 원본 계산에서 곱하면 오차 0.22%, 그대로 쓰면 53%, 나누면 76%였습니다.

45도 방향을 나타내는 한 Bloch 1D 계산에서 z축을 따라 이동하는 Ex 펄스
파트 A의 실제 1D run 한 개, θ = 45°입니다. 비스듬한 평면파 성분을 z축에서 관찰한 모습으로, 3D 공간 전체의 애니메이션은 아닙니다.

거울 옆에서는 반사된 field가 source의 field와 더해집니다. 거울에 평행한 전기 쌍극자는 거울 아래 같은 거리에 부호가 반대인 image를 놓아 설명할 수 있습니다. 둘의 경로차 2h cos θ가 방향마다 달라서 밝은 방향과 어두운 방향이 번갈아 생깁니다.

설명용 도식: PEC 위 쌍극자와 거울 아래 반대 부호 image의 대칭 위치 실제 쌍극자 (+)image (−) hh PEC 면접선 전기장이 거울면에서 상쇄
거울의 경계 조건을 설명하는 도식이며, 아래쪽 image는 실제로 추가한 광원이 아닙니다. 파트 B는 이 대칭으로 2D 거울 문제를 풉니다.

파트 B는 2D Ez·배경 n = 1.2·파장 650 nm·높이 h = 1.25 µm입니다. 반면 파트 C의 Bloch 계산은 k_point 때문에 셀 벽이 주기경계이므로, 아래쪽에 명시적인 mp.metal 블록을 넣어 거울을 만듭니다. 모든 거울은 손실 없는 PEC입니다.

4. 직접 실행하기: 거울과의 거리만 줄이기

Meep 1.33.0이 있는 환경에서 저장소의 code/ 폴더에서 원본을 실행하고 결과를 따로 보관합니다. 단일 코어의 기존 실행 기록은 약 4.3분입니다.

OMP_NUM_THREADS=1 python dipole_pattern_3d.py

높이 H만 1.25에서 0.3 µm로 바꿔 같은 명령을 실행하세요. 전체 코드의 H = 1.25를 H = 0.3으로 바꿉니다. 파트 B와 C가 공유하는 높이이므로 두 방법에 같은 변화가 적용됩니다.

05_pec_pattern.png에서 밝은 봉우리(lobe)의 개수와 각도를 원본과 비교하세요. h가 작아지면 위상차의 변화 폭도 작아져 봉우리가 줄어들 것으로 예상할 수 있습니다. 새 봉우리 위치와 오차는 실행 결과에서 읽고, 진공인 파트 A의 0.22%와 거울 계산의 오차를 섞지 마세요.

5. 결과 해석하기: 정확한 패턴에도 적용 범위가 있다

원본에서 비교한 것 상대 L2 오차
진공 3D 패턴, 계산한 240개 방향 0.22%
2D near2far와 해석 array factor 0.66%
거울 위 1D Bloch와 2D, 72° 아래 6.4%
거울 위 1D Bloch φ = 90°와 해석해, 85°까지 10.5%
거울 위 쌍극자의 다섯 방사 봉우리와 2D near2far 및 Bloch 1D 결과의 차이
원본 높이 1.25 µm에서 다섯 lobe가 보이며 최대 봉우리는 12.9°입니다. 회색 띠는 72° 이상의 영역입니다. 서로 다른 모델을 정규화한 패턴의 적절한 단면에서 비교합니다.

거울이 없는 경우의 0.22%를 거울 문제 전체의 정확도로 가져오면 안 됩니다. 거울 계산은 72° 아래에서도 두 방법이 6.4% 다릅니다. 원문은 거울 위치의 격자 반 칸 오차와 각도 표본 간격을 가능한 원인으로 해석하며, 여기서 두 효과를 독립적으로 검증한 것은 아닙니다.

말할 수 없는 범위. 72° 이상의 1D 방사 세기, 절대 power와 directivity, 손실 금속 거울의 응답은 검증하지 않았습니다. 2D near2far도 그 큰 각도 영역의 수렴성을 별도로 확인하지 않았습니다.

6. 이해 확인하기

  1. 1D run 하나로 3D 패턴 전체를 얻을 수 있나요? 필요한 반복과 환산을 설명해 보세요.
  2. 2D 거울 애니메이션과 3D 패턴을 비교할 때, 회색 빈칸과 6.4% 오차를 어떻게 해석해야 하나요?
두 질문의 답 확인하기
  1. 한 run은 한 방향의 표본입니다. 여러 k_point로 반복하고 z flux에 cos θ를 곱해 방향별 패턴을 구성합니다.
  2. 2D Ez와 3D Ex의 적절한 단면을 정규화한 모양으로 비교합니다. 회색은 계산하지 않은 영역이고, 6.4%는 72° 아래에서도 남은 두 방법의 차이입니다. 절대 방출량의 일치를 뜻하지 않습니다.

7. 참고 자료와 전체 코드

방향별 계산 설정, 원본의 실패 사례와 상세 수치, 전체 프로그램을 아래에 보관했습니다.

English summary

TL;DR (English)

점광원의 빛은 어느 방향으로 나갈까? — hero 원본 그림
  • What: post 01 left the point source radiating equally in all directions, in 2D. This post asks the 3D question twice. First, the 3D pattern of an x-polarized dipole in vacuum without a 3D cell: one 1D simulation per direction, with the direction encoded in a transverse Bloch wavevector. Second, the same dipole above a perfect-electric-conductor mirror, solved in 2D with an opposite-sign image dipole and a closed near2far box, and again with the 1D method.
  • Result: 240 one-dimensional runs reproduce the dipole pattern $1-\sin^2\theta\cos^2\phi$ with 0.22% relative error on the computed hemisphere; multiplying the z flux by $\cos\theta$ is the right conversion (dividing gives 76%). Above the mirror the 2D near2far pattern matches the two-element array factor $\sin^2(kh\cos\theta)$ to 0.66% with five lobes; the 1D method agrees with it to 6.4% below 72°, and breaks down at grazing angles where the PML cannot absorb a wave travelling almost parallel to it.
  • Takeaway: a 3D pattern can be bought with many cheap 1D runs, but only away from grazing angles, and the per-direction flux needs a Jacobian. An infinite mirror is never put inside a near2far box: it is replaced by an image source and a symmetry. A mirror does not just reflect; it rewrites the pattern of the source next to it.
  • Code: full script at the bottom, ~4.3 min on one core.
배경·물리식·파라미터 자세히 보기

원본 §0 · 이 글에서 배우는 것

  • 3D 점광원의 방사 패턴을 3D 셀 없이 얻는 법: 방향 하나 = k_point가 다른 1D run 하나
  • 1D run의 z flux를 입체각당 power로 바꾸는 환산 인자 $\cos\theta$와, 그것을 틀리게 잡으면 어떻게 보이는지
  • glancing angle(72° 이상)을 공식 예제가 계산하지 않는 이유. 0으로 남은 표본은 방사 null이 아니다
  • 무한 PEC 거울을 near2far box 안에 넣을 수 없을 때: 부호가 반대인 image dipole과 Mirror(Y, phase=-1)
  • Near2FarRegion 네 조각의 weight가 닫힌 면의 바깥 법선이라는 것
  • 두 방법(2D near2far, 1D Bloch)이 같은 array factor를 내는지, 어디서 갈라지는지

전제 지식: 01편의 점원과 flux box, 03편의 reference run. 공식 예제: Near-to-far field spectra 튜토리얼의 antenna above a PEC ground plane과 dipole_in_vacuum_1D.py. 이전 글: 09 · Waveguide bend inverse design · 다음 글: 11 · 두 거울 사이의 점광원

원본 §1 · 무엇을 알고 싶은가

01편은 2D 점원이 네 면으로 25%씩 나간다는 데서 끝났다. 실제 점광원은 3D이고 축이 있다. x 방향으로 진동하는 쌍극자는 x축 방향으로는 빛을 내지 않고 그에 수직한 면에서는 고르게 낸다. 이것을 Meep으로 확인하려면 3D 셀이 필요할 것 같지만, 공식 예제는 1D run 수백 개로 같은 답을 얻는다. 왜 그것이 가능한지, 그리고 어디서 안 되는지가 첫 질문이다. 두 번째 질문은 시즌 2의 출발점이다. 점광원 옆에 거울 하나를 두면 방사 패턴은 어떻게 바뀌는가.

어디에 쓰이는가

거울 위의 쌍극자는 OLED와 LED의 발광층 그 자체다. 반사 전극 위에 놓인 발광 분자의 방사 패턴이 outcoupling의 출발점이고, 1D Bloch run 묶음은 다층 OLED의 광추출 계산에서 실제로 쓰는 방법이다.

응용 이 글의 어떤 것을 쓰는가 그 다음에 필요한 것
OLED·LED: 반사 전극 위의 발광층 거울 위 쌍극자의 패턴, 1D Bloch 방법(다층으로 확장 가능) 14편 광추출 효율
패치·모노폴 안테나(ground plane 위) image 이론, array factor sin²(kh cosθ) —
양자점·단일광자원의 방출 방향 3D 쌍극자 패턴, 편광 축 11편 LDOS
메타표면·격자의 far field 닫힌 near2far box의 규칙 16편 far field

원본 §2 · 물리 한 페이지

점광원의 field는 평면파의 합이다. 횡방향 파수 $\mathbf k_\perp=(k_x,k_y)$를 하나 고정하면 Maxwell 방정식은 z만 남은 1D 문제가 되고, 그 1D 해는 $e^{i\mathbf k_\perp\cdot\mathbf r_\perp}$를 곱한 평면파다. Meep에서 이것이 k_point다. 방향 $(\theta,\phi)$로 나가는 평면파는 $\mathbf k_\perp=f\sin\theta\,(\cos\phi,\sin\phi)$를 가지므로, 1D 셀에 쌍극자를 두고 k_point를 바꿔 가며 돌리면 run 하나가 방향 하나의 표본이 된다. 1D run이 주는 것은 그 평면파 성분의 z 방향 flux $S_z$다. 입체각당 power로 바꾸려면 $d^2k_\perp=f^2\cos\theta\,d\Omega$의 Jacobian이 들어가 $S_r=S_z\cos\theta$가 된다.

\[\frac{dP}{d\Omega}\Big\lvert _{x\text{-dipole}}\propto 1-\sin^2\theta\cos^2\phi,\qquad S_r(\theta,\phi)=S_z(\theta,\phi)\cos\theta,\qquad \big\lvert 1-e^{\,i\,2kh\cos\theta}\big\lvert ^2=4\sin^2(kh\cos\theta),\quad k=\frac{2\pi n}{\lambda}\]

$\theta$가 90°에 가까우면 평면파가 PML과 거의 평행하게 진행한다. PML은 법선 방향으로 들어오는 파를 흡수하도록 만든 층이라 이 파는 흡수되지 않고 셀을 오간다. 공식 예제는 $|\mathbf k_\perp|>0.95f$, 즉 $\theta>71.8°$를 계산하지 않는다.

거울 위의 쌍극자는 image 이론으로 푼다. 거울에 접한 전기장은 0이어야 하므로 거울 아래 같은 거리에 부호가 반대인 쌍극자를 두면 거울면에서 두 field가 상쇄된다. 거울을 지우고 쌍극자 둘을 두는 것과 같다. 둘의 경로차가 $2h\cos\theta$이므로 방사 패턴에 array factor $4\sin^2(kh\cos\theta)$가 곱해진다. 2D Ez 쌍극자의 자체 패턴은 등방이라 2D에서는 이 인자가 패턴의 전부다.

기호 뜻 코드 변수
$\theta,\phi$ 극각(+z 또는 거울 법선에서), 방위각(x축에서) POLAR, AZIM, THETA_B
$\mathbf k_\perp$ 횡방향 Bloch 파수 $f\sin\theta(\cos\phi,\sin\phi)$ k_point
$S_z$, $S_r$ 1D run의 z flux, 환산한 radial flux flux_z, radial
$h$ 쌍극자와 거울 사이 거리 H
$kh$ 경로차의 위상 척도 K_B * H
image 부호 −1인 두 번째 source amplitude=-1.0

가정과 유효 범위: 파트 A는 진공, 단일 주파수, Ex 편광. 파트 B는 2D Ez(거울에 접한 편광), 배경 n = 1.2, 파장 650 nm, 거울은 손실 없는 PEC. 파트 C는 3D Ex 쌍극자이고 거울은 1D 셀 아래쪽의 명시적인 mp.metal 블록이다. k_point가 있으면 셀 벽 자체는 Bloch 주기경계다. 패턴은 모두 최대값으로 정규화한 모양 비교이며 절대 power는 다루지 않는다.

결과 보기 전에 맞춰보기

물리량 내 예측 근거
1D run 묶음 vs 해석 패턴 (계산한 반구) 2% 안 10_sources 노트의 10×12 격자에서 1.99%
z flux → radial flux 환산 $\cos\theta$를 곱한다 Jacobian $d^2k_\perp=f^2\cos\theta\,d\Omega$
$\phi=90°$ 단면 상수(등방) 쌍극자 축에 수직한 면
2D PEC near2far vs array factor 1% 안 노트의 res 100에서 0.47%
거울면 $y=0$의 $\lvert E_z\rvert$ 0 odd symmetry가 강제
0~90°의 lobe 수 5개 (12.8°, 40.7°, 57.2°, 71.0°, 83.8°) $kh=14.5$, 극대는 $kh\cos\theta=(m+\tfrac12)\pi$
1D Bloch PEC($\phi=90°$) vs 2D near2far 72° 아래에서 2% 안 같은 array factor, 쌍극자 인자는 그 면에서 1
72° 위의 1D run 틀어진다 PML이 평행파를 흡수하지 못한다

판정 기준: 계산한 반구의 상대 L2 > 5%면 환산 인자나 k_point를 의심한다. $y=0$의 $\lvert E_z\rvert$가 최대의 수 % 이상이면 symmetry 위상이 틀렸다(격자 반 칸 때문에 정확히 0은 아니다). 두 방법이 72° 아래에서 10% 이상 다르면 한쪽의 거울이나 monitor 위치를 의심한다.

원본 §3 · 시뮬레이션 설계도

파트 A·C의 1D 셀. z축만 계산한다. 양 끝 PML(파트 C는 위쪽만, 아래는 PEC), 빨간 선 = Ex 쌍극자, 파란 네모 = flux 점. 보라색 화살표가 `k_point`로 정해지는 전파 방향이다. 동그라미 숫자는 §4의
파트 A·C의 1D 셀. z축만 계산한다. 양 끝 PML(파트 C는 위쪽만, 아래는 PEC), 빨간 선 = Ex 쌍극자, 파란 네모 = flux 점. 보라색 화살표가 k_point로 정해지는 전파 방향이다. 동그라미 숫자는 §4의 단계 번호다.
파트 B의 2D 셀(7 × 7 µm, n = 1.2). 빨간 점 두 개가 물리 쌍극자(y = +1.25)와 image 쌍극자(y = −1.25, 진폭 −1), 파란 사각형이 닫힌 near2far box, 녹색 빗금이 PML. y =
파트 B의 2D 셀(7 × 7 µm, n = 1.2). 빨간 점 두 개가 물리 쌍극자(y = +1.25)와 image 쌍극자(y = −1.25, 진폭 −1), 파란 사각형이 닫힌 near2far box, 녹색 빗금이 PML. y = 0이 유효 PEC 면이고 위쪽 절반만 물리적이다.
파라미터 값 왜 이 값인가 바꾸면
A 파장, 해상도, 공기층 1 µm, res 50, 10 µm 패턴은 스케일에 무관. 공식 예제 값 해상도는 환산 인자와 무관하다
A 각도 격자 극각 13 × 방위각 24 공식 30 × 50의 축소판. 7.5°·15° 간격 촘촘할수록 run 수에 비례해 느려진다
A glancing 한계 $\sin\theta>0.95$ 건너뜀 공식 규칙. PML 평행파 계산하면 run이 오래 걸리고 값이 틀린다(파트 C에서 보임)
A 종료 Ex 감쇠 1e-6 (25 단위 창) 공식 예제 값 설정이 맞으면 run당 1초 안에 끝난다
A k_point $nf(\sin\theta\cos\phi,\ \sin\theta\sin\phi,\ \cos\theta)$ z 성분으로 항상 $\mathbf k\neq0$ §4 ③
B 파장, n, h 650 nm, 1.2, 1.25 µm 공식 예제 값. $kh=14.5$ h가 작아지면 lobe가 줄어든다
B 해상도 100 노트와 같다. 파장당 83칸 50이면 L2가 커진다
B near2far box 반폭 2 µm 두 쌍극자(±1.25)를 감싼다 box가 한쪽 쌍극자만 감싸면 image 이론이 깨진다
B 원거리 반지름 1000 λ far field 근사 —
C 셀 metal 0.5 + h 1.25 + 공기 10 + PML 1 µm k_point가 있으면 셀 벽은 Bloch 주기라 거울은 mp.metal 블록으로 벽을 거울로 믿으면 거울이 없다(§4 ④)
C 종료 고정 150 time unit 85°의 파가 공기 10 µm(n 1.2)를 가로지르는 시간 140 감쇠 조건은 glancing에서 정체
파트 B의 source 파형과 스펙트럼(650 nm, fwidth 0.2 fcen). 파트 A는 파장 1 µm에 같은 상대 대역폭이다.
파트 B의 source 파형과 스펙트럼(650 nm, fwidth 0.2 fcen). 파트 A는 파장 1 µm에 같은 상대 대역폭이다.

강의 노트북과의 차이: 강의 범위 밖이다. 01편(강의 week 2)의 점광원을 3D와 거울로 확장한다. 10_sources의 두 PEC 노트가 각각 2D near2far(L2 0.47%)와 1D Bloch(상관 0.947)를 따로 다뤘는데, 이 글은 둘을 같은 축에 올려 어디서 갈라지는지 본다.

원본 코드 단계별 설명

원본 §4 · 코드 따라가기

읽는 순서: 단위·파라미터 → 재료·구조 → source → Simulation·경계 → monitor → 실행·종료 → 후처리. 파트 A·C는 1D라 ②가 없고, 파트 B는 ②가 “거울 대신 image + symmetry”다.

① 단위와 파라미터 — 어떤 숫자를 고정하는가

POLAR = np.radians(np.arange(0.0, 90.1, 7.5))      # 13 polar angles (0 = +z)
AZIM = np.radians(np.arange(0.0, 360.0, 15.0))     # 24 azimuth angles
GLANCING = 0.95                                     # skip k_perp > 0.95 f (official rule)
T_AFTER = 60.0                                      # run time after the source turns off

WL_B, N_B, H, RES_B = 0.65, 1.2, 1.25, 100          # PEC mirror part: wavelength, background index, height, resolution
K_B = 2 * np.pi * N_B / WL_B                        # k h = 14.5 sets the lobes
  • 무엇: 파트 A의 각도 격자와 glancing 한계, 파트 B의 거울 문제 파라미터.
  • 왜: 각도 격자는 run 수다. 13 × 24에서 glancing 3행을 빼면 240 run. $kh$는 lobe의 수와 위치를 정하므로 파장·굴절률·높이 셋을 한 묶음으로 적는다.
  • 틀리면: K_B에 배경 굴절률을 빼먹으면 array factor의 lobe가 다른 각도에 온다.

② 재료와 구조 — 거울 대신 image와 symmetry

sources_B = [mp.Source(mp.GaussianSource(FCEN_B, fwidth=FWIDTH_B), component=mp.Ez, center=mp.Vector3(0, H)),
             mp.Source(mp.GaussianSource(FCEN_B, fwidth=FWIDTH_B), component=mp.Ez, center=mp.Vector3(0, -H), amplitude=-1.0)]
symB = [mp.Mirror(mp.X), mp.Mirror(mp.Y, phase=-1)]        # odd in y -> Ez = 0 on y = 0 (the PEC plane)
  • 무엇: 거울은 geometry에 없다. 부호가 반대인 두 번째 쌍극자와 y에 대한 odd mirror symmetry가 거울이다.
  • 왜: 무한 PEC 판을 near2far box가 가로지를 수 없다. 두 쌍극자를 box가 감싸게 하면 변환 가정이 유지된다. symmetry는 계산을 1/4로 줄이고 $y=0$의 $E_z=0$을 정확히 강제한다.
  • 틀리면: phase=-1을 빼면 두 쌍극자가 같은 부호로 더해져 $y=0$이 node가 아니라 antinode가 되고, 패턴은 $\cos^2$ 형이 된다. Hz 편광이면 image 부호와 parity가 반대다.

③ Source — 1D 셀의 쌍극자와 k_point

def bloch_k(theta, phi, fcen, n_index=1.0):          # full wavevector of the outgoing plane wave, |k| = n f
    return mp.Vector3(n_index * fcen * np.sin(theta) * np.cos(phi), n_index * fcen * np.sin(theta) * np.sin(phi), n_index * fcen * np.cos(theta))

sim = mp.Simulation(cell_size=mp.Vector3(0, 0, sz), resolution=RES_A, k_point=bloch_k(theta, phi, fcen, n_index),   # no dimensions=1 (see below)
                    default_material=mp.Medium(index=n_index), boundary_layers=[mp.PML(thickness=DPML_A, direction=mp.Z)],
                    sources=[mp.Source(mp.GaussianSource(fcen, fwidth=fwidth), component=mp.Ex, center=mp.Vector3(0, 0, z_src), size=mp.Vector3())])
  • 무엇: 셀은 z 한 줄이고 source는 그 위의 한 점이다. k_point가 나가는 평면파의 파수 벡터 전체(횡방향 두 성분과 z 성분)를 준다.
  • 왜: 같은 1D 구조에서 k_point만 바꾸면 다른 방향의 평면파 성분이 된다. 3D 셀을 돌리지 않고 방향별 표본을 얻는 원리다. z 성분은 PML이 흡수하는 방향이라 물리에는 영향이 없지만, $\theta=0$에서도 $\mathbf k\neq0$이 되게 해 모든 run이 복소 field를 쓰도록 만든다.
  • 틀리면: 두 가지를 이 글에서 직접 겪었다. dimensions=1을 명시하면 횡방향 k가 조용히 무시되어 flux가 각도에 무관해진다(패턴 L2 35%). z 성분 없이 $\theta=0$을 돌리면 그 run만 실수 field가 되어 power가 1/4로 나온다. 셀 크기 (0, 0, sz)만으로 1D가 되므로 dimensions는 쓰지 않는다.

④ Simulation과 경계 — PML의 방향과 거울

boundary_layers=[mp.PML(thickness=DPML_A, direction=mp.Z)]                     # part A: both ends of z
boundary_layers=[mp.PML(thickness=DPML_A, direction=mp.Z, side=mp.High)]       # part C: PML on top only ...
mirror = [mp.Block(center=mp.Vector3(0, 0, Z_BOT + 0.5 * DMETAL), size=mp.Vector3(mp.inf, mp.inf, DMETAL), material=mp.metal)]   # ... and a PEC block at the bottom
  • 무엇: 파트 A는 양 끝 PML. 파트 C는 위쪽만 PML이고 아래에는 mp.metal(완전도체) 블록을 둔다. 그 블록의 윗면이 거울이다.
  • 왜: 01편에서는 PML 없는 셀 벽이 거울이었다. 그러나 k_point를 주면 모든 셀 벽이 Bloch 주기 경계로 바뀌므로 아래 벽은 더 이상 완전도체가 아니다. 거울은 geometry로 넣어야 한다.
  • 틀리면: 이 글의 두 번째 실행이 그랬다. 아래 벽을 거울로 믿고 PML만 위에 두었더니 패턴이 array factor와 43% 어긋났다. 아래 벽이 위쪽 PML로 이어지는 주기 경계였기 때문이다.

⑤ Monitor — 1D의 flux 점과 2D의 near2far box

mon = sim.add_flux(fcen, 0, 1, mp.FluxRegion(center=mp.Vector3(0, 0, z_mon)))          # a point in 1D: Poynting z-flux

n2f = sim_B.add_near2far(FCEN_B, 0, 1,
        mp.Near2FarRegion(center=mp.Vector3(0, BOX), size=mp.Vector3(2 * BOX, 0)),
        mp.Near2FarRegion(center=mp.Vector3(0, -BOX), size=mp.Vector3(2 * BOX, 0), weight=-1),
        mp.Near2FarRegion(center=mp.Vector3(BOX, 0), size=mp.Vector3(0, 2 * BOX)),
        mp.Near2FarRegion(center=mp.Vector3(-BOX, 0), size=mp.Vector3(0, 2 * BOX), weight=-1))
  • 무엇: 1D에서는 flux monitor가 점 하나다. 2D에서는 네 조각이 닫힌 사각형을 이루고 아래·왼쪽 조각의 weight=-1이 바깥 법선을 맞춘다.
  • 왜: near2far 변환은 닫힌 면 위의 등가 전류에서 먼 field를 계산한다. 면이 열려 있거나 법선 부호가 틀리면 변환이 성립하지 않는다.
  • 틀리면: weight를 빼면 아래 조각이 안쪽을 보게 되어 패턴이 뒤틀린다. 01편의 flux box에서 면의 방향을 맞춘 것과 같은 규칙이다.

⑥ 실행 — 감쇠 조건과 고정 시간

sim.run(until_after_sources=mp.stop_when_fields_decayed(25, mp.Ex, mon_pt, 1e-6))   # part A (official): until Ex at the flux point has decayed
sim.run(until_after_sources=T_C)                                                    # part C: fixed 150 time units (grazing angles included)
sim_B.run(until_after_sources=mp.stop_when_dft_decayed(tol=1e-6))                   # part B: until the DFT monitors stop changing
  • 무엇: 파트 A는 공식 예제처럼 flux 점의 Ex가 감쇠할 때까지. 파트 C는 고정 시간. 파트 B는 DFT 수렴까지.
  • 왜: 파트 C는 일부러 glancing 각까지 돌린다. 그 각에서는 PML이 흡수하지 못한 파가 셀을 오가며 감쇠 조건이 오래 정체하므로, 85°의 파가 공기층 10 µm를 가로지르는 시간(약 140)에서 상한을 정했다.
  • 틀리면: 고정 시간이 짧으면 큰 $\theta$의 run에서 펄스가 monitor에 닿기 전에 끝나 패턴이 바깥쪽에서 꺼진다. 감쇠 조건을 glancing 각에 쓰면 run이 수십 분을 돈다.

⑦ 후처리 — Jacobian, 정규화, 해석해 비교

radial = flux_z * np.cos(POLAR)[:, None]                        # S_r = S_z cos(theta)
analytic_A = 1 - np.sin(TH) ** 2 * np.cos(PH) ** 2              # x-dipole, up to a constant
err = rel_l2(norm(radial), norm(analytic_A))                    # both normalized to their maximum

ff = sim_B.get_farfield(n2f, mp.Vector3(R_FF * np.sin(th), R_FF * np.cos(th)))
S = np.real(np.cross(E, np.conj(H)));  pattern_B[i] = np.hypot(S[0], S[1])
array_factor = np.sin(K_B * H * np.cos(THETA_B)) ** 2
  • 무엇: z flux에 $\cos\theta$를 곱하고 최대값으로 정규화해 해석 패턴과 L2로 비교한다. 2D는 far field의 Poynting 크기를 각도별로 구한다.
  • 왜: 정규화한 모양만 비교한다. 1D run의 절대 flux와 2D near2far의 절대 power는 단위가 달라 같은 축에 둘 수 없다.
  • 틀리면: $\cos\theta$로 나누면 L2가 76%로 커진다(§5 그림의 빨간 ×). 계산하지 않은 glancing 표본을 0으로 넣고 L2를 재면 오차가 수십 %가 되는데 그것은 물리가 아니라 빈칸이다.

함정: 이 글의 첫 실행은 dimensions=1을 명시한 채였고, 그때는 $\theta=0$의 감쇠 조건이 time step 백만을 넘겨도 멈추지 않았으며 flux는 모든 각도에서 같았다. dimensions를 지우고 k_point에 z 성분을 넣자 공식 예제의 감쇠 조건이 run당 1초 안에 끝났다. 멈추지 않는 run은 대개 종료 조건이 아니라 설정의 문제다. until_after_sources에 조건 두 개를 리스트로 주면 둘 다 만족해야 멈추므로 stop_after_walltime은 상한이 되지 못한다.

원본 결과·검증 표·오류 진단·추가 탐구

원본 §5 · 결과

파트 A. 위: =0 단면은 ^2, =90° 단면은 상수. 파란 점이 S_z, 빨간 ×가 S_z/(틀린 환산). 오른쪽 막대가 세 환산의 L2. 아래: 계산한 반구의 Meep·해석·차이 지도. 회색 띠는 계산하지 않은 glancing
파트 A. 위: $\phi=0$ 단면은 $\cos^2\theta$, $\phi=90°$ 단면은 상수. 파란 점이 $S_z\cos\theta$, 빨간 ×가 $S_z/\cos\theta$(틀린 환산). 오른쪽 막대가 세 환산의 L2. 아래: 계산한 반구의 Meep·해석·차이 지도. 회색 띠는 계산하지 않은 glancing 영역이다.
환산 상대 L2 (계산한 240 표본)
$S_z\cos\theta$ 0.22%
$S_z$ 그대로 53%
$S_z/\cos\theta$ 76%
같은 스크립트의 첫 실행. `dimensions=1`을 명시하고 `k_point`에 z 성분이 없었다. Meep 지도(왼쪽 아래)가 에 전혀 의존하지 않고 =0 행만 어둡다. 두 증상이 각각 "횡방향 k가 무시됨"과
같은 스크립트의 첫 실행. dimensions=1을 명시하고 k_point에 z 성분이 없었다. Meep 지도(왼쪽 아래)가 $\phi$에 전혀 의존하지 않고 $\theta=0$ 행만 어둡다. 두 증상이 각각 “횡방향 k가 무시됨”과 “k = 0이라 실수 field”의 지문이다. L2 0.35. 그림은 틀렸지만 어디가 틀렸는지를 말해 주기 때문에 남겨 둔다.
파트 B. 쌍극자 + image의 정상상태 Ez. 흰 점선 y=0이 거울면이고 그 위의 E_z는 최대의 0.012배다. 위쪽 절반만 물리적이다. 점선 사각형이 near2far box.
파트 B. 쌍극자 + image의 정상상태 Ez. 흰 점선 $y=0$이 거울면이고 그 위의 $\lvert E_z\rvert$는 최대의 0.012배다. 위쪽 절반만 물리적이다. 점선 사각형이 near2far box.
왼쪽: 거울 위 쌍극자의 패턴. 파란 선이 2D near2far, 검은 점선이 array factor, 초록 점이 1D Bloch(=90°), 빨간 ×가 glancing 각. 가운데: =0 단면은 array factor에 쌍극자의 ^
왼쪽: 거울 위 쌍극자의 패턴. 파란 선이 2D near2far, 검은 점선이 array factor, 초록 점이 1D Bloch($\phi=90°$), 빨간 ×가 glancing 각. 가운데: $\phi=0$ 단면은 array factor에 쌍극자의 $\cos^2\theta$가 곱해진다. 오른쪽: 각도별 오차. 회색 띠가 72° 위다.
방법 비교 대상 상대 L2
B: 2D near2far (Ez) $\sin^2(kh\cos\theta)$, 50각 0.66% (peak bin 차이 0)
C: 1D Bloch (Ex, $\phi=90°$), 72° 아래 $\sin^2(kh\cos\theta)$ 6.8%
C: 같은 것, 85°까지 포함 〃 10.5% (상관 0.981)
C: 1D Bloch ($\phi=0$), 72° 아래 $\cos^2\theta\,\sin^2(kh\cos\theta)$ 6.0%
B vs C, 72° 아래 서로 6.4%

예측과 비교

물리량 내 예측 (§2) 시뮬레이션 판정
1D run 묶음 vs 해석 패턴 2% 안 0.22% ✅
환산 인자 $\cos\theta$ 곱 곱 0.22%, 나눔 76% ✅
$\phi=90°$ 단면 상수 상수 ✅
2D PEC vs array factor 1% 안 0.66% ✅
$y=0$의 $\lvert E_z\rvert$ 0 최대의 0.012배 ✅
lobe 수 5개 5개, 최대 12.9° ✅
1D Bloch PEC vs 2D 2% 안 6.4% ❌ (6.4%)
72° 위의 1D run 틀어짐 85°까지 넣으면 L2 10.5% ✅

예측 여덟 중 일곱이 맞았고 하나가 틀렸다. 1D Bloch 방법은 거울 위에서도 lobe의 위치와 수를 정확히 재현하지만 진폭이 72° 아래에서도 6% 어긋난다. 원인은 두 가지로 본다. 거울 면이 Yee 격자의 반 칸(10 nm) 안에서 불확실해 $kh$가 0.12 rad 흔들리면 $\theta=0$의 lobe 진폭이 5% 바뀐다. 그리고 5° 간격 표본은 폭이 10° 남짓한 lobe의 봉우리와 골을 비껴 지나므로 정규화의 기준이 되는 최대값 자체가 표본 위치에 좌우된다. 2D near2far는 이 두 문제가 없고 0.66%다. 10_sources의 1D Bloch PEC 노트가 상관 0.947에서 멈춘 것은 같은 한계이고, 이 글은 glancing 각을 빼면 0.98, 넣으면 0.105의 L2로 그 경계를 숫자로 남긴다. 진공에서는 거울이 없으니 격자 반 칸 문제가 없고 0.22%가 나온다.

수렴성

변수 값 결과 비고
A 각도 격자 13 × 24 (이 글) vs 30 × 50 (노트 0724) L2 0.22% vs 0.22% 표본 수는 L2를 바꾸지 않는다. 각 표본이 독립된 run이라 격자는 해상도가 아니라 그림의 촘촘함이다. 노트 0722의 1.99%는 고정 시간 종료의 값
C glancing 포함 여부 72° 아래 / 85°까지 6.8% / 10.5% 노트 0722의 상관 0.947은 glancing을 포함한 값이었다
B 해상도 100 (이 글, 노트와 동일) 0.66% 노트 0.47%. 해상도 사다리는 직접 해보기

주장할 수 있는 것 / 없는 것

  • 할 수 있는 것: x 쌍극자의 3D 패턴은 72° 아래에서 1D run 묶음으로 0.22% 안에 재현된다. $S_z\cos\theta$가 맞는 환산이다. 거울 위 쌍극자의 패턴은 image 이론의 array factor와 0.66% 안에서 같고, 1D 방법도 72° 아래에서는 같은 답을 준다.
  • 할 수 없는 것: 72° 위의 방사 세기. 1D 방법은 그 영역을 계산하지 못하고, 이 글의 2D near2far도 그 영역의 수렴성을 따로 보지 않았다. 절대 power와 directivity. 손실 있는 금속 거울. y 편광과 다른 해상도로의 일반화.

원본 §6 · 흔한 실수

증상 원인 고치는 법
flux가 각도에 무관, 패턴 L2 35% dimensions=1을 명시해 횡방향 k가 무시됨 dimensions를 빼고 cell_size=(0, 0, sz)로만 1D를 만든다
$\theta=0$ run만 power가 1/4 $\mathbf k=0$이라 실수 field로 전환 k_point에 z 성분 $f\cos\theta$를 넣어 항상 복소 field
1D run이 끝나지 않음 위 설정 오류, 또는 glancing 각의 PML 정체 설정을 고치고, glancing 각은 고정 until_after_sources
패턴이 $\theta$ 큰 쪽에서 과대 $S_z/\cos\theta$ 환산 $S_z\cos\theta$
반구 L2가 30%대 계산하지 않은 glancing 표본을 0으로 포함 계산한 표본만 비교하고 빈칸은 빈칸으로 그린다
$y=0$이 antinode image 부호 또는 phase=-1 누락 Ez는 odd, Hz는 even
lobe 각도가 전부 어긋남 $k$에 배경 굴절률 누락 $k=2\pi n/\lambda$, 파트 C의 k_point에도 n
near2far 패턴이 뒤틀림 box 조각의 weight 부호 아래·왼쪽 조각 −1
파트 C에서 거울이 사라짐(L2 43%) k_point가 셀 벽을 Bloch 주기로 바꿈 거울은 mp.metal 블록으로 geometry에 넣는다
1D Bloch의 lobe 진폭이 5% 어긋남 거울 면이 Yee 격자 반 칸(10 nm) 안에서 불확실, $kh$가 0.12 rad 흔들림 해상도를 올리거나 h를 격자에 맞춘다

원본 §7 · 직접 해보기

바꿀 것 예상 변화 확인할 수치
파트 A를 y 쌍극자로 패턴이 $\phi$ 방향으로 90° 돈다 $\phi=0$ 단면이 상수가 되는지
GLANCING 0.95 → 0.99 72~82° 표본이 생기지만 오차가 큼 그 행의 |Meep − 해석|
파트 B의 h를 0.3 µm로 $kh=3.5$, lobe 1~2개 peak 각도
파트 B 해상도 50 / 100 / 150 L2 사다리 0.66%가 어디서 정체하는지
파트 B를 Hz 편광으로 image 부호 +1, Mirror(Y, phase=+1) $y=0$이 antinode인지
code/dipole_pattern_3d.py 전체 (클릭하여 펼치기) 
"""Meep Example 10 - 3D radiation pattern of a point dipole: a family of 1D Bloch runs, and a PEC mirror.

Post 01 showed a 2D point source radiating equally in all directions. This post asks the 3D question in two ways.
  A. Vacuum Ex dipole, 3D pattern WITHOUT a 3D cell: one 1D simulation per direction (theta, phi), each with a
     transverse Bloch wavevector k = f (sin t cos p, sin t sin p, 0). The z flux of each run, times cos(theta),
     is one angular sample of the 3D pattern. Compared with the analytic dipole pattern 1 - sin^2(t) cos^2(p).
  B. A dipole 1.25 um above a perfect-electric-conductor (PEC) mirror, 2D (Ez): the mirror is replaced by an
     opposite-sign image dipole plus an odd mirror symmetry, and the far field comes from a closed near2far box.
     Compared with the two-element array factor sin^2(k h cos t).
  C. The same mirror problem with the 1D Bloch method of part A (3D Ex dipole, PEC = metallic cell boundary):
     the two methods agree on the pattern away from grazing angles; near grazing the 1D method breaks down.

Run:  python dipole_pattern_3d.py     (~3 min on one core)
Out:  00_source.png, 01_layout.png, 02_layout_1d.png, 03_vacuum_pattern.png, 04_pec_field.png, 05_pec_pattern.png,
      06_anim_pec.gif, 07_anim_1d.gif, result.json   (-> ../assets/10/)
"""
import json
import os
import sys
import time

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from matplotlib import animation
import meep as mp

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from blogfig import Label, _badge, animate_fields, annotated_layout, record_frames, source_figure   # noqa: E402

HERE = os.path.dirname(os.path.abspath(__file__))
OUT = os.path.join(HERE, "..", "assets", "10")
os.makedirs(OUT, exist_ok=True)
t_all = time.time()


def rel_l2(a, b):
    a, b = np.asarray(a, float), np.asarray(b, float)
    return float(np.linalg.norm(a - b) / np.linalg.norm(b))


# =================================================================== A. vacuum dipole via 1D Bloch runs
# ---------------------------------------------------------------- (1) parameters (official dipole_in_vacuum_1D.py, smaller grid)
WL_A = 1.0                               # wavelength [um]; the pattern is scale-free
FCEN_A = 1 / WL_A
FWIDTH_A = 0.1 * FCEN_A
RES_A = 50
DPML_A, DAIR_A = 1.0, 10.0
SZ_A = DPML_A + DAIR_A + DPML_A
Z_SRC_A = -0.5 * DAIR_A                  # dipole at the bottom of the air gap (official)
Z_MON_A = 0.5 * DAIR_A                   # flux point at the top of the air gap
GLANCING = 0.95                          # skip k_perp > 0.95 f: PML cannot absorb nearly-parallel waves (official rule)
POLAR = np.radians(np.arange(0.0, 90.1, 7.5))      # 13 polar angles (0 = +z)
AZIM = np.radians(np.arange(0.0, 360.0, 15.0))     # 24 azimuth angles


def bloch_k(theta, phi, fcen, n_index=1.0):
    """Full wavevector of the outgoing plane wave, |k| = n f. The z component keeps k != 0 at theta = 0,
    so every run uses complex fields (a k = 0 run would switch to real fields and change the power scale by 4)."""
    return mp.Vector3(n_index * fcen * np.sin(theta) * np.cos(phi), n_index * fcen * np.sin(theta) * np.sin(phi), n_index * fcen * np.cos(theta))


def flux_1d(theta, phi, *, fcen, fwidth, n_index=1.0, sz=SZ_A, z_src=Z_SRC_A, z_mon=Z_MON_A, pml=None, geometry=(), component=mp.Ex, until=None):
    """One 1D run: Bloch k from (theta, phi), source at z_src, Poynting z-flux at z_mon.
    NOTE: do not pass dimensions=1. The cell size (0, 0, sz) already makes the run 1D, and an explicit dimensions=1
    silently drops the transverse k (the flux then no longer depends on the angle)."""
    sim = mp.Simulation(cell_size=mp.Vector3(0, 0, sz), resolution=RES_A, k_point=bloch_k(theta, phi, fcen, n_index),
                        default_material=mp.Medium(index=n_index), geometry=list(geometry),
                        boundary_layers=pml if pml is not None else [mp.PML(thickness=DPML_A, direction=mp.Z)],
                        sources=[mp.Source(mp.GaussianSource(fcen, fwidth=fwidth), component=component, center=mp.Vector3(0, 0, z_src), size=mp.Vector3())])
    mon = sim.add_flux(fcen, 0, 1, mp.FluxRegion(center=mp.Vector3(0, 0, z_mon), size=mp.Vector3(), direction=mp.Z))
    sim.run(until_after_sources=until if until is not None else mp.stop_when_fields_decayed(25, component, mp.Vector3(0, 0, z_mon), 1e-6))
    f = float(mp.get_fluxes(mon)[0]); sim.reset_meep()
    return f


t_a = time.time()
flux_z = np.full((len(POLAR), len(AZIM)), np.nan)
for i, th in enumerate(POLAR):
    if np.sin(th) > GLANCING:
        continue
    for j, ph in enumerate(AZIM):
        flux_z[i, j] = flux_1d(th, ph, fcen=FCEN_A, fwidth=FWIDTH_A)
n_runs = int(np.sum(~np.isnan(flux_z)))
computed = ~np.isnan(flux_z)
cos_t = np.cos(POLAR)[:, None]
radial = flux_z * cos_t                                   # official: radial flux = (kz / f) * flux_z
TH, PH = np.meshgrid(POLAR, AZIM, indexing="ij")
analytic_A = 1 - np.sin(TH) ** 2 * np.cos(PH) ** 2        # |E|^2 of an x-polarized dipole, up to a constant


def norm(p, mask):
    return p / np.nanmax(np.where(mask, p, np.nan))


err_mul = rel_l2(norm(radial, computed)[computed], norm(analytic_A, computed)[computed])
err_div = rel_l2(norm(flux_z / cos_t, computed)[computed], norm(analytic_A, computed)[computed])
err_raw = rel_l2(norm(flux_z, computed)[computed], norm(analytic_A, computed)[computed])
j0 = 0; j90 = int(np.argmin(np.abs(AZIM - np.pi / 2)))
err_phi0 = rel_l2(norm(radial, computed)[computed[:, j0], j0], norm(analytic_A, computed)[computed[:, j0], j0])
print(f"A: {n_runs} 1D runs ({len(POLAR)}x{len(AZIM)} grid, {int(np.sum(~computed))} glancing samples skipped) in {time.time() - t_a:.0f} s; "
      f"rel L2 vs analytic (computed samples): flux_z*cos = {err_mul:.4f}, flux_z/cos = {err_div:.4f}, flux_z raw = {err_raw:.4f}; phi=0 cut {err_phi0:.4f}")

# schematic of the 1D cell (plot2D has nothing to draw in 1D)
fig, ax = plt.subplots(figsize=(8.6, 3.2))
ax.axhspan(-0.5, 0.5, xmin=0, xmax=DPML_A / SZ_A, color="green", alpha=0.25); ax.axhspan(-0.5, 0.5, xmin=1 - DPML_A / SZ_A, xmax=1, color="green", alpha=0.25)
ax.plot([Z_SRC_A, Z_SRC_A], [-0.4, 0.4], color="red", lw=3); ax.plot(Z_MON_A, 0, "s", color="blue", ms=9)
th_demo = np.radians(45)
ax.annotate("", xy=(Z_SRC_A + 2.2 * np.cos(th_demo), 0.45 * np.sin(th_demo)), xytext=(Z_SRC_A, 0), arrowprops=dict(arrowstyle="->", color="purple", lw=1.8))
ax.text(Z_SRC_A + 1.4, 0.36, "k = f (sin t cos p, sin t sin p, cos t)\nonly the z axis is simulated", color="purple", fontsize=8)
for xy, step, color, txt, txy in (((-0.5 * SZ_A + 0.3, 0.42), 1, "dimgray", f"wl={WL_A} um, res={RES_A}\n{len(POLAR)} polar x {len(AZIM)} azimuth runs", (-0.5 * SZ_A + 0.6, 0.30)),
                                   ((Z_SRC_A, -0.42), 3, "red", "Ex dipole (GaussianSource)", (Z_SRC_A + 0.25, -0.46)),
                                   ((-0.5 * SZ_A + 0.5 * DPML_A, 0), 4, "green", "PML (both ends)", (-0.5 * SZ_A + 0.1, -0.15)),
                                   ((Z_MON_A, 0.12), 5, "blue", "flux point: Poynting z-flux", (Z_MON_A - 2.6, 0.18)),
                                   ((Z_MON_A, -0.12), 6, "purple", "decay watch point", (Z_MON_A - 1.9, -0.3))):
    _badge(ax, xy, step, color); ax.text(*txy, txt, fontsize=8, color=color)
ax.set_xlim(-0.5 * SZ_A, 0.5 * SZ_A); ax.set_ylim(-0.5, 0.5); ax.set_yticks([]); ax.set_xlabel("z [um]")
ax.set_title("part A: one 1D cell per direction; the transverse Bloch wavevector k_point picks the direction (theta, phi)", fontsize=9)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "02_layout_1d.png"), dpi=150); plt.close(fig)

# pattern figure: two polar cuts + hemisphere maps
fig = plt.figure(figsize=(13, 7.6))
gs = fig.add_gridspec(2, 3)
for col, (j, lab, an) in enumerate(((j0, "phi = 0 (plane of the dipole axis): cos^2(theta)", np.cos(POLAR) ** 2),
                                    (j90, "phi = 90 deg (plane normal to the dipole): isotropic", np.ones_like(POLAR)))):
    ax = fig.add_subplot(gs[0, col], projection="polar")
    m = computed[:, j]
    ax.plot(POLAR[m], norm(radial, computed)[m, j], "o", color="tab:blue", ms=4, label="Meep: flux_z cos(theta)")
    ax.plot(POLAR, an, "-", color="k", lw=1.2, label="analytic")
    ax.plot(POLAR[m], norm(flux_z / cos_t, computed)[m, j], "x", color="tab:red", ms=4, alpha=0.6, label="flux_z / cos(theta) (wrong)")
    ax.set_theta_zero_location("N"); ax.set_theta_direction(-1); ax.set_thetamin(0); ax.set_thetamax(90); ax.set_rlim(0, 1.6)
    ax.set_title(lab, fontsize=9); ax.legend(fontsize=7, loc="lower left")
ax = fig.add_subplot(gs[0, 2])
ax.bar(["flux_z cos", "flux_z raw", "flux_z / cos"], [err_mul, err_raw, err_div], color=["tab:green", "tab:gray", "tab:red"])
for k_, v in enumerate([err_mul, err_raw, err_div]):
    ax.text(k_, v + 0.01, f"{v:.3f}", ha="center", fontsize=8)
ax.set_ylabel("relative L2 vs analytic (computed samples)"); ax.set_title("which conversion of the z flux is the radial flux?", fontsize=9); ax.grid(axis="y", alpha=0.3)
Td, Pd = np.degrees(POLAR), np.degrees(AZIM)
for col, (data, ttl, cmap, vmax) in enumerate(((norm(radial, computed), "Meep: normalized radial flux", "viridis", 1.0),
                                                (norm(analytic_A, computed), "analytic 1 - sin^2(t) cos^2(p)", "viridis", 1.0),
                                                (np.abs(norm(radial, computed) - norm(analytic_A, computed)), "|Meep - analytic|", "magma", None))):
    ax = fig.add_subplot(gs[1, col])
    pc = ax.pcolormesh(Pd, Td, np.where(computed, data, np.nan), cmap=cmap, vmin=0, vmax=vmax, shading="nearest")
    ax.axhspan(np.degrees(np.arcsin(GLANCING)), 90, color="lightgray", alpha=0.6); ax.text(5, 80, "not computed (glancing)", fontsize=7)
    ax.set_xlabel("azimuth phi [deg]"); ax.set_ylabel("polar theta [deg]"); ax.set_title(ttl, fontsize=9); fig.colorbar(pc, ax=ax, shrink=0.85)
fig.suptitle(f"3D pattern of an x-dipole from {n_runs} 1D runs: rel L2 {err_mul:.3f} on the computed hemisphere", fontsize=10)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "03_vacuum_pattern.png"), dpi=150); plt.close(fig)

# GIF of one oblique 1D run (theta = 45 deg): Re(Ex) along z vs time
th_g = np.radians(45)
sim_g = mp.Simulation(cell_size=mp.Vector3(0, 0, SZ_A), resolution=RES_A, k_point=bloch_k(th_g, 0.0, FCEN_A),
                      boundary_layers=[mp.PML(thickness=DPML_A, direction=mp.Z)],
                      sources=[mp.Source(mp.GaussianSource(FCEN_A, fwidth=0.4 * FCEN_A), component=mp.Ex, center=mp.Vector3(0, 0, Z_SRC_A), size=mp.Vector3())])
sim_g.init_sim()
t0g = 5 / (0.4 * FCEN_A)
frames_g, times_g = [], []
sim_g.run(until=t0g - 2 / (0.4 * FCEN_A))
for i in range(50):
    sim_g.run(until=0.3)
    frames_g.append(np.real(sim_g.get_array(center=mp.Vector3(), size=mp.Vector3(0, 0, SZ_A), component=mp.Ex)))
    times_g.append(sim_g.meep_time())
zs = np.linspace(-0.5 * SZ_A, 0.5 * SZ_A, len(frames_g[0]))
lim_g = max(np.max(np.abs(f)) for f in frames_g)
fig_g, ax_g = plt.subplots(figsize=(7.6, 2.9))
ln, = ax_g.plot(zs, frames_g[0], color="tab:blue"); ax_g.set_ylim(-lim_g, lim_g); ax_g.set_xlim(zs[0], zs[-1])
ax_g.axvspan(zs[0], zs[0] + DPML_A, color="green", alpha=0.2); ax_g.axvspan(zs[-1] - DPML_A, zs[-1], color="green", alpha=0.2)
ax_g.axvline(Z_SRC_A, color="red", lw=1.5, label="source"); ax_g.axvline(Z_MON_A, color="blue", lw=1.5, ls="--", label="flux point")
ax_g.set_xlabel("z [um]"); ax_g.set_ylabel("Re(Ex)"); ax_g.legend(fontsize=7, loc="upper right"); ttl_g = ax_g.set_title("", fontsize=9)
fig_g.tight_layout()


def _upd(i):
    ln.set_ydata(frames_g[i]); ttl_g.set_text(f"one 1D run (theta = 45 deg): the pulse moves along z at c cos(theta)   t = {times_g[i]:.1f} um/c")
    return ln, ttl_g


animation.FuncAnimation(fig_g, _upd, frames=len(frames_g), blit=False).save(os.path.join(OUT, "07_anim_1d.gif"), writer=animation.PillowWriter(fps=10), dpi=80)
plt.close(fig_g); sim_g.reset_meep()

# =================================================================== B. dipole above a PEC mirror, 2D near2far with an image dipole
# ---------------------------------------------------------------- (1) parameters (official antenna_pec_ground_plane.py)
WL_B = 0.65
FCEN_B = 1 / WL_B
FWIDTH_B = 0.2 * FCEN_B
N_B = 1.2
H = 1.25                                 # dipole height above the mirror
RES_B = 100
DPML_B, DBULK = 0.5, 6.0
S_B = DBULK + 2 * DPML_B                 # 7 x 7 cell
R_FF = 1000 * WL_B
NANG = 50
THETA_B = np.linspace(0, 0.5 * np.pi, NANG)          # angle from the mirror normal (+y)
K_B = 2 * np.pi * N_B / WL_B
array_factor = np.sin(K_B * H * np.cos(THETA_B)) ** 2
array_factor /= array_factor.max()

sources_B = [mp.Source(mp.GaussianSource(FCEN_B, fwidth=FWIDTH_B), component=mp.Ez, center=mp.Vector3(0, H)),
             mp.Source(mp.GaussianSource(FCEN_B, fwidth=FWIDTH_B), component=mp.Ez, center=mp.Vector3(0, -H), amplitude=-1.0)]   # image dipole
symB = [mp.Mirror(mp.X), mp.Mirror(mp.Y, phase=-1)]                                                                        # odd in y -> Ez = 0 on y = 0 (PEC)
common_B = dict(cell_size=mp.Vector3(S_B, S_B), resolution=RES_B, boundary_layers=[mp.PML(DPML_B)], default_material=mp.Medium(index=N_B))
sim_B = mp.Simulation(sources=sources_B, symmetries=symB, **common_B)
BOX = 2.0                                                                                                                  # half-size of the near2far box (encloses both dipoles)
n2f = sim_B.add_near2far(FCEN_B, 0, 1,
                        mp.Near2FarRegion(center=mp.Vector3(0, BOX), size=mp.Vector3(2 * BOX, 0)),
                        mp.Near2FarRegion(center=mp.Vector3(0, -BOX), size=mp.Vector3(2 * BOX, 0), weight=-1),
                        mp.Near2FarRegion(center=mp.Vector3(BOX, 0), size=mp.Vector3(0, 2 * BOX)),
                        mp.Near2FarRegion(center=mp.Vector3(-BOX, 0), size=mp.Vector3(0, 2 * BOX), weight=-1))
dft_B = sim_B.add_dft_fields([mp.Ez], FCEN_B, 0, 1, center=mp.Vector3(), size=mp.Vector3(DBULK, DBULK))
annotated_layout(
    sim_B, os.path.join(OUT, "01_layout.png"), dpml=DPML_B, figsize=(6.6, 6.2), axis_step=1.0,
    title="part B: dipole above a PEC mirror = dipole + opposite image, odd mirror symmetry in y",
    params_text=f"wl={WL_B} um, n={N_B}\nh={H} um, res={RES_B}\nk h = {K_B * H:.1f}",
    params_xy=(-3.4, 3.1), pml_xy=(-3.0, -3.25), decay_point=None,
    labels=[Label("physical Ez dipole at y = +h", (0.05, H), (0.6, 2.4), step=3, color="red"),
            Label("image dipole at y = -h, amplitude -1", (0.05, -H), (0.6, -2.4), step=3, color="red"),
            Label("y = 0: Ez = 0 here (effective PEC)", (-1.2, 0.0), (-3.4, -0.9), step=2, color="black"),
            Label("closed near2far box (4 segments)", (BOX, 1.0), (0.4, 1.4), step=5, color="blue")])
source_figure(FCEN_B, FWIDTH_B, os.path.join(OUT, "00_source.png"), wl_scale=1000.0, wl_unit="nm", time_unit="um/c")
t_b = time.time()
sim_B.run(until_after_sources=mp.stop_when_dft_decayed(tol=1e-6))
ez_B = sim_B.get_dft_array(dft_B, mp.Ez, 0)
pattern_B = np.zeros(NANG)
for i, th in enumerate(THETA_B):
    ff = sim_B.get_farfield(n2f, mp.Vector3(R_FF * np.sin(th), R_FF * np.cos(th)))
    E = np.array(ff[:3]); Hf = np.array(ff[3:])
    S = np.real(np.cross(E, np.conj(Hf)))
    pattern_B[i] = np.hypot(S[0], S[1])
sim_B.reset_meep()
pattern_B /= pattern_B.max()
err_B = rel_l2(pattern_B, array_factor)
peak_B, peak_an = int(np.argmax(pattern_B)), int(np.argmax(array_factor))
node = float(np.max(np.abs(ez_B[:, ez_B.shape[1] // 2])) / np.max(np.abs(ez_B)))
print(f"B: 2D near2far pattern vs sin^2(k h cos theta): rel L2 {err_B:.4f}, peak bin Meep {peak_B} vs analytic {peak_an} "
      f"({np.degrees(THETA_B[peak_B]):.1f} deg), |Ez| on the y = 0 line / max = {node:.1e}; {time.time() - t_b:.0f} s")

ext_B = [-0.5 * DBULK, 0.5 * DBULK, -0.5 * DBULK, 0.5 * DBULK]
fig, ax = plt.subplots(1, 2, figsize=(10.5, 4.6))
lim = float(np.max(np.abs(ez_B)))
ax[0].imshow(np.real(ez_B).T, extent=ext_B, origin="lower", cmap="RdBu", vmin=-lim, vmax=lim, aspect="equal"); ax[0].set_title("Re(Ez) at the center frequency", fontsize=9)
ax[1].imshow(np.abs(ez_B).T, extent=ext_B, origin="lower", cmap="inferno", aspect="equal"); ax[1].set_title("|Ez|: the y = 0 line is a node (the mirror)", fontsize=9)
for a in ax:
    a.axhline(0, color="w", ls="--", lw=1.0); a.plot([0, 0], [H, -H], "o", color="lime", ms=4)
    a.add_patch(plt.Rectangle((-BOX, -BOX), 2 * BOX, 2 * BOX, fill=False, color="cyan", lw=1.0, ls=":")); a.set_xlabel("x [um]")
ax[0].set_ylabel("y [um]")
fig.suptitle("part B: steady-state field of dipole + image. Only the upper half (y > 0) is physical.", fontsize=10)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "04_pec_field.png"), dpi=150); plt.close(fig)

# GIF: monitor-free run with a short pulse, both dipoles visible, node line marked
sim_gB = mp.Simulation(sources=[mp.Source(mp.GaussianSource(FCEN_B, fwidth=0.5 * FCEN_B), component=mp.Ez, center=mp.Vector3(0, H)),
                                mp.Source(mp.GaussianSource(FCEN_B, fwidth=0.5 * FCEN_B), component=mp.Ez, center=mp.Vector3(0, -H), amplitude=-1.0)],
                       symmetries=symB, **dict(common_B, resolution=50))
sim_gB.init_sim()
vol_gB = mp.Volume(center=mp.Vector3(), size=mp.Vector3(DBULK, DBULK))
t0B = 5 / (0.5 * FCEN_B)
frames_B, times_B = record_frames(sim_gB, vol_gB, mp.Ez, t_start=t0B - 2 / (0.5 * FCEN_B), t_end=t0B + 1.1 * 0.5 * DBULK * N_B * 1.5, n_frames=60)
animate_fields(frames_B, times_B, ext_B, os.path.join(OUT, "06_anim_pec.gif"), figsize=(5.6, 5.0), dpi=70,
               lines=[((-0.5 * DBULK, 0), (0.5 * DBULK, 0), "k", "mirror plane y = 0 (Ez node)"), ((-BOX, BOX), (BOX, BOX), "blue", "near2far box (top)")],
               points=[(0, H, "red", "dipole"), (0, -H, "orange", "image dipole (-1)")], title="dipole + image", legend_loc="lower right")
sim_gB.reset_meep()

# =================================================================== C. the mirror problem with the 1D Bloch method (3D Ex dipole above PEC)
# A k_point makes EVERY cell boundary Bloch-periodic, so the mirror cannot be the cell wall: it is a block of mp.metal
# (perfect electric conductor) at the bottom of the 1D cell. PML only at the top; background n = 1.2.
DMETAL = 0.5
SZ_C = DMETAL + H + DAIR_A + DPML_A
Z_BOT = -0.5 * SZ_C
Z_PEC = Z_BOT + DMETAL                               # mirror surface
Z_SRC_C = Z_PEC + H
Z_MON_C = Z_PEC + H + DAIR_A
mirror = [mp.Block(center=mp.Vector3(0, 0, Z_BOT + 0.5 * DMETAL), size=mp.Vector3(mp.inf, mp.inf, DMETAL), material=mp.metal)]
POLAR_C = np.radians(np.arange(0.0, 90.0, 5.0))      # includes grazing angles on purpose
T_C = 150.0                                          # fixed duration: at 85 deg the wave needs ~140 time units to cross 10 um of n = 1.2
flux_C = {}
for phi_deg in (90.0, 0.0):
    vals = [flux_1d(th, np.radians(phi_deg), fcen=FCEN_B, fwidth=0.1 * FCEN_B, n_index=N_B, sz=SZ_C, z_src=Z_SRC_C, z_mon=Z_MON_C,
                    pml=[mp.PML(thickness=DPML_A, direction=mp.Z, side=mp.High)], geometry=mirror, until=T_C) for th in POLAR_C]
    flux_C[phi_deg] = np.array(vals) * np.cos(POLAR_C)
af_C = np.sin(K_B * H * np.cos(POLAR_C)) ** 2
an_C = {90.0: af_C, 0.0: af_C * np.cos(POLAR_C) ** 2}             # phi=0: times the dipole's own cos^2
ok_C = np.sin(POLAR_C) <= GLANCING
res_C = {}
for phi_deg in (90.0, 0.0):
    p = flux_C[phi_deg] / flux_C[phi_deg][ok_C].max(); a = an_C[phi_deg] / an_C[phi_deg][ok_C].max()
    res_C[phi_deg] = {"pattern": p, "analytic": a, "err_in": rel_l2(p[ok_C], a[ok_C]), "err_all": rel_l2(p, a),
                      "corr_all": float(np.corrcoef(p, a)[0, 1])}
    print(f"C [phi = {phi_deg:.0f} deg]: 1D Bloch, {len(POLAR_C)} angles: rel L2 {res_C[phi_deg]['err_in']:.4f} below the glancing limit, "
          f"{res_C[phi_deg]['err_all']:.4f} with grazing angles included (correlation {res_C[phi_deg]['corr_all']:.4f})")
pB_on_C = np.interp(POLAR_C, THETA_B, pattern_B)
err_BC = rel_l2(res_C[90.0]["pattern"][ok_C], pB_on_C[ok_C])
print(f"B vs C: 2D near2far (Ez) vs 1D Bloch (Ex, phi = 90 deg) on the same angles: rel L2 {err_BC:.4f}")

fig = plt.figure(figsize=(13, 4.6))
ax = fig.add_subplot(1, 3, 1, projection="polar")
ax.plot(THETA_B, pattern_B, "-", color="tab:blue", lw=1.6, label="B: 2D near2far (Ez dipole)")
ax.plot(THETA_B, array_factor, "--", color="k", lw=1.2, label="analytic sin^2(k h cos t)")
ax.plot(POLAR_C[ok_C], res_C[90.0]["pattern"][ok_C], "o", color="tab:green", ms=4, label="C: 1D Bloch (Ex, phi = 90)")
ax.plot(POLAR_C[~ok_C], res_C[90.0]["pattern"][~ok_C], "x", color="tab:red", ms=6, label="C: grazing angles")
ax.set_theta_zero_location("N"); ax.set_theta_direction(-1); ax.set_thetamin(0); ax.set_thetamax(90); ax.set_rlim(0, 1.3)
ax.set_title(f"dipole {H} um above a PEC, k h = {K_B * H:.1f}", fontsize=9); ax.legend(fontsize=6.5, loc="lower left")
ax = fig.add_subplot(1, 3, 2, projection="polar")
ax.plot(POLAR_C[ok_C], res_C[0.0]["pattern"][ok_C], "o", color="tab:green", ms=4, label="C: 1D Bloch, phi = 0")
ax.plot(POLAR_C[~ok_C], res_C[0.0]["pattern"][~ok_C], "x", color="tab:red", ms=6, label="grazing")
ax.plot(POLAR_C, res_C[0.0]["analytic"], "--", color="k", lw=1.2, label="analytic cos^2(t) sin^2(k h cos t)")
ax.set_theta_zero_location("N"); ax.set_theta_direction(-1); ax.set_thetamin(0); ax.set_thetamax(90); ax.set_rlim(0, 1.3)
ax.set_title("phi = 0: array factor times the dipole's cos^2", fontsize=9); ax.legend(fontsize=6.5, loc="lower left")
ax = fig.add_subplot(1, 3, 3)
for phi_deg, c in ((90.0, "tab:green"), (0.0, "tab:olive")):
    ax.plot(np.degrees(POLAR_C), np.abs(res_C[phi_deg]["pattern"] - res_C[phi_deg]["analytic"]), "o-", color=c, ms=4, label=f"1D Bloch, phi = {phi_deg:.0f}")
ax.plot(np.degrees(THETA_B), np.abs(pattern_B - array_factor), "-", color="tab:blue", lw=1.4, label="2D near2far")
ax.axvspan(np.degrees(np.arcsin(GLANCING)), 90, color="lightgray", alpha=0.6); ax.text(np.degrees(np.arcsin(GLANCING)) + 1, 0.02, "glancing:\nPML fails", fontsize=7)
ax.set_xlabel("theta from the mirror normal [deg]"); ax.set_ylabel("|pattern - analytic| (normalized)"); ax.set_yscale("log"); ax.set_ylim(1e-4, 2)
ax.grid(alpha=0.3); ax.legend(fontsize=7); ax.set_title("where each method fails", fontsize=9)
fig.suptitle(f"B: rel L2 {err_B:.4f} (near2far) | C: {res_C[90.0]['err_in']:.4f} below 72 deg, {res_C[90.0]['err_all']:.3f} with grazing angles", fontsize=10)
fig.tight_layout(rect=[0, 0, 1, 0.92]); fig.savefig(os.path.join(OUT, "05_pec_pattern.png"), dpi=150); plt.close(fig)

if mp.am_master():
    with open(os.path.join(OUT, "result.json"), "w") as f:
        json.dump({"A": {"wl": WL_A, "res": RES_A, "n_polar": len(POLAR), "n_azimuth": len(AZIM), "n_runs": n_runs, "n_skipped": int(np.sum(~computed)),
                         "glancing_limit_deg": float(np.degrees(np.arcsin(GLANCING))), "err_mul": err_mul, "err_div": err_div, "err_raw": err_raw, "err_phi0": err_phi0},
                   "B": {"wl": WL_B, "n": N_B, "h": H, "res": RES_B, "kh": K_B * H, "box": BOX, "err": err_B, "peak_bin": [peak_B, peak_an],
                         "peak_deg": float(np.degrees(THETA_B[peak_B])), "node_ratio": node,
                         "pattern": pattern_B.tolist(), "analytic": array_factor.tolist(), "theta_deg": np.degrees(THETA_B).tolist()},
                   "C": {str(int(k_)): {"err_in": v["err_in"], "err_all": v["err_all"], "corr_all": v["corr_all"], "pattern": v["pattern"].tolist()} for k_, v in res_C.items()},
                   "B_vs_C": err_BC, "theta_C_deg": np.degrees(POLAR_C).tolist(),
                   "wall_s_total": time.time() - t_all, "meep": mp.__version__}, f, indent=2)
print(f"total {time.time() - t_all:.0f} s")
원본 실행 기록과 재현 환경

§4의 발췌 코드와 달리 전체 코드에는 1D 셀 설계도 그리기, 반구 지도, GIF 두 개, result.json 기록이 들어 있다. 그림 helper blogfig.py는 시리즈 공통이며 같은 폴더(code/)에 있다. 전체 코드와 helper: https://github.com/jin-castle/meep-examples/blob/main/code.

실행 결과 (2026-10-23 실행):

A: 240 1D runs (13x24 grid, 72 glancing samples skipped) in 201 s; rel L2 vs analytic (computed samples): flux_z*cos = 0.0022, flux_z/cos = 0.7585, flux_z raw = 0.5290; phi=0 cut 0.0012
B: 2D near2far pattern vs sin^2(k h cos theta): rel L2 0.0066, peak bin Meep 7 vs analytic 7 (12.9 deg), |Ez| on the y = 0 line / max = 1.2e-02; 3 s
C [phi = 90 deg]: 1D Bloch, 18 angles: rel L2 0.0675 below the glancing limit, 0.1052 with grazing angles included (correlation 0.9809)
C [phi = 0 deg]: 1D Bloch, 18 angles: rel L2 0.0599 below the glancing limit, 0.0601 with grazing angles included (correlation 0.9965)
B vs C: 2D near2far (Ez) vs 1D Bloch (Ex, phi = 90 deg) on the same angles: rel L2 0.0637
total 258 s

재현 환경: meep 1.33.0 · Python 3.11 · conda install -c conda-forge pymeep · 실행 python dipole_pattern_3d.py (약 4.3 min, 단일 코어)

공식 문서와 다음 글

]]>jin-castleMeep Example 14 · 박막 속 점광원, 공기로 나오는 몫 — 광추출 효율, LDOS 정규화, kz 적분, CYL 대 3D2026-10-23T00:00:00+00:002026-10-23T00:00:00+00:00https://jin-castle.github.io/meep-examples/extraction-efficiencyTL;DR (English)

hero

  • What: post 11 measured how much a dipole emits (LDOS); post 13 split a body of revolution into m runs. An LED asks for the ratio: of everything a dipole in the emitting layer puts out, how much reaches the air. Extraction efficiency = flux through an open surface in air ÷ the source’s own work from dft_ldos. Three official examples: a dipole in a layer on a mirror (cylindrical vs 3D), the same slab with the dipole off the axis (an m series), and a dipole inside the cleaved facet of a laser stack (a 2D cross-section plus a kz integral).
  • Result: A dipole halfway up the layer sends 0.323 of its power into air (cylindrical, resolution 80); the efficiency swings from 0.52 near the mirror to 0.09 near the top, and at resolution 40 cylindrical and 3D disagree by up to 16 %: a 0.29 µm layer needs resolution 80. 3.5 µm off the axis, the official stop rule (first m below 1 %) halts at m = 32 and reports 0.632; the series rebounds at m ≈ 41, where the slab-guided emission lives, and the sum to m = 60 gives 0.362, matching the on-axis 0.364. The cleaved laser facet needs 76 kz runs and extracts 22.4 %; a single 2D run (kz = 0) would claim 32.9 %.
  • Takeaway: the denominator is not a vacuum constant but the dipole’s own work, and its voxel volume differs between coordinate systems (2πr/res² vs 1/res³ vs 1/res²). Most of the light stays guided in a high-index film. Where you cut a series (m or kz) changes the answer, and the official “first term below 1 %” rule can stop before the guided light arrives.
  • Code: full script at the bottom, ~77 min (mpirun -np 4; B alone 58 min).

0. 이 글에서 배우는 것

  • 광추출 효율의 정의: 분자는 공기 쪽 열린 flux 면, 분모는 dft_ldos의 source 일 $-\mathrm{Re}(FJ^*)\,\Delta V$
  • 좌표계마다 다른 $\Delta V$: cylindrical $2\pi r/\mathrm{res}^2$, 3D $1/\mathrm{res}^3$, 2D $1/\mathrm{res}^2$
  • 같은 문제를 cylindrical과 3D로 풀어 맞추는 교차검증. 어디서 어긋나는가
  • 축에서 떨어진 쌍극자의 m 급수에서 “언제 멈출까”가 결과를 바꾸는 경우
  • 한 방향으로 균일한 구조(절단면 레이저)의 3D 문제 = 2D 단면 + kz 적분

전제 지식: 11편의 dft_ldos, 13편의 cylindrical 좌표와 m 급수. 공식 예제: LDOS 튜토리얼의 LED 추출 효율 · nonaxisymmetric dipole sources · 스크립트 extraction_eff_ldos.py · point_dipole_cyl.py · edge_emitter_2D.py. 이전 글: 13 · 회전 대칭으로 3D를 계산하기 · 다음 글: 15 · 점광원이 수천 개일 때

1. 무엇을 알고 싶은가

13편 끝 질문이었다. 디스크 안의 쌍극자를 LED의 발광층으로 보면, 쌍극자가 낸 빛 중 몇 %가 공기로 나오는가. 굴절률 2.4인 층에서 공기로 나가려면 임계각 25° 안쪽으로 계면에 닿아야 하고, 나머지는 전반사로 층 안을 따라간다. 이 몫을 재려면 두 숫자가 필요하다. 공기로 나간 power와 쌍극자가 낸 전체 power. 앞의 것은 flux monitor로 잰다. 뒤의 것은 11편처럼 거울과 층이 방출량 자체를 바꾸므로 진공의 상수로 둘 수 없고, 그 구조 속에서 source가 한 일로 재야 한다. 그리고 3D 문제를 싸게 푸는 세 길(cylindrical, 대칭을 쓴 3D, 2D + kz)이 같은 답을 주는지 본다.

어디에 쓰이는가

광추출 효율은 발광 소자의 외부 양자 효율(EQE) = 내부 양자 효율 × 추출 효율에서 뒤쪽 인자다. 소자 설계의 대부분이 이 숫자를 올리는 일이다.

응용 이 글의 어떤 것을 쓰는가 그 다음에 필요한 것
OLED·LED·micro-LED 발광층 설계 높이(전극과의 거리)에 따른 추출 효율, LDOS 분모 15편 수천 개의 발광체
반도체 레이저·SOA의 절단면 2D 단면 + kz 적분, 편광별 추출 18편 계면의 각도 응답
양자점·단일광자원 수집 효율 축 위/축 밖 쌍극자의 차이, m 급수 16편 far field로 모으기
광추출 구조(텍스처, 렌즈, 광결정) 최적화 분자·분모 정의와 교차검증 절차 35편 near2far 역설계

2. 물리 한 페이지

추출 효율은 두 power의 비다. 분자는 공기 쪽에 둔 열린 flux 면으로 잰다. 분모는 source 점에서 field가 전류에 한 일이고, dft_ldos가 저장한 $F$(field)와 $J$(전류)로 계산한다. source 하나가 차지하는 부피 $\Delta V$가 좌표계마다 다르다.

\[\eta=\frac{P_{\mathrm{air}}}{P_{\mathrm{total}}},\qquad P_{\mathrm{total}}=-\mathrm{Re}\{F\,J^*\}\,\Delta V,\qquad \Delta V=\begin{cases}2\pi r/\mathrm{res}^2 & \text{cylindrical}\\ 1/\mathrm{res}^3 & \text{3D}\\ 1/\mathrm{res}^2 & \text{2D (line current)}\end{cases}\]

축에서 떨어진 쌍극자(cylindrical)와 한 방향으로 균일한 구조의 점광원(2D)은 둘 다 급수로 푼다. 앞은 m에 대해, 뒤는 kz에 대해. 서로 다른 m(또는 kz)은 직교하므로 power는 항별로 더한다. ±m과 ±kz는 같은 power를 주므로 0이 아닌 항은 두 배로 센다.

\[\eta_{\mathrm{off\text{-}axis}}=\frac{\sum_m w_m P^{(m)}_{\mathrm{air}}}{\sum_m w_m P^{(m)}_{\mathrm{total}}},\qquad \eta_{\mathrm{edge}}=\frac{P_{\mathrm{air}}(0)+2\sum_{k_z>0}P_{\mathrm{air}}(k_z)}{P_{\mathrm{tot}}(0)+2\sum_{k_z>0}P_{\mathrm{tot}}(k_z)},\qquad w_0=1,\ w_{m>0}=2\]

고굴절률 층에 갇힌 빛(guided mode)은 층을 따라 반지름 방향으로 간다. 축에서 r만큼 떨어진 쌍극자가 낸 guided 빛은 방위 차수 $m\approx 2\pi n_{\mathrm{eff}} r/\lambda$ 근처의 항에 실린다. 이 빛이 셀 끝의 옆면 monitor를 지나가면 분자에 들어가므로, 그 m까지 가기 전에 급수를 끊으면 다른 숫자가 나온다.

기호 뜻 코드 변수
$\eta$ 추출 효율 p_air / p_tot
$h$ 거울에서 쌍극자까지 높이 / 층 두께 HEIGHTS
$F, J$ dft_ldos가 저장한 source 점의 field와 전류 sim.ldos_Fdata, sim.ldos_Jdata
$\Delta V$ source 한 개의 부피 2*pi*r/res**2, 1/res**3, 1/res**2
$m$, $k_z$ 급수의 항 m=, k_point=(0,0,kz)

가정과 유효 범위: 파장 1 µm, 손실 없는 층과 완전도체 거울(A·B), 손실 없는 다층(C). 분자는 열린 면이라 “공기 쪽으로 나간 몫”이지 닫힌 에너지 수지가 아니다. 셀의 가로 크기 L(A: 6 µm, B: 20 µm)이 유한하므로 그 밖으로 가는 빛은 옆면에서 센다.

결과 보기 전에 맞춰보기

물리량 내 예측 근거
추출 효율(A, h = 0.5) 0.3 근처 노트 0.323(CYL)·0.337(3D)
높이 의존 거울에서 멀수록 변한다 쌍극자와 image의 간섭(10편)
CYL res 40 vs 80 1% 안 파장당 40칸 이상
3D vs CYL 2% 안 노트 max 0.017
축 위 쌍극자(B) 0.3 근처 같은 층, 다른 셀 크기
B: 공식 종료 규칙 sum-to-60과 다르다 노트: 0.63–0.74 vs 0.36
C: 필요한 kz 수 70~80 노트 76
C: 추출 효율 22% 근처 노트 22.4%

판정 기준: 효율이 0 아래나 1 위면 분모의 $\Delta V$나 flux 면의 부호가 틀렸다. CYL과 3D가 2배 다르면 voxel 부피, 5~10%면 해상도나 source 위치를 의심한다.

3. 시뮬레이션 설계도

layout 파트 A의 cylindrical (r, z) 셀(x가 r, y가 z). 회색 층이 n 2.4(두께 0.292 µm), 그 아래 셀 벽이 PML 없는 완전도체 거울이다. 빨간 점이 축에서 1.5 픽셀 떨어진 Er 쌍극자, 파란 선이 분자를 재는 열린 flux 면(위와 옆). 파란 빗금은 대표 DFT 영역. 동그라미 숫자는 §4의 단계 번호다.

layout edge 파트 C의 2D 단면. 왼쪽에서부터 기판(n 3.2), 클래딩(1.5), 활성층(2.3), 클래딩이 쌓인 다층이 x = 1.5 µm에서 잘려 있고(절단면), 그 오른쪽은 공기다. 쌍극자는 절단면 0.5 µm 안쪽의 활성층. z 방향으로 구조가 균일하므로 kz마다 2D run 하나를 돌린다.

파라미터 값 왜 이 값인가 바꾸면
A 층 n 2.4, 두께 0.7λ/n = 0.292 µm, 거울 위 공식 값 두께가 바뀌면 guided mode 수가 바뀐다
A 높이 0.1~0.9, 9점 공식 21점의 축소 —
A 해상도 CYL 40·80, 3D 40 공식 80. 3D는 비용 때문에 40 3D res 80은 셀 하나 4500만 칸
A 수집면 가로 6 µm, 공기층 1 µm 공식 값 좁으면 옆으로 나간 빛을 놓친다
B 셀 r 20 µm, 층 같음, res 50 공식 point_dipole_cyl.py —
B 쌍극자 r = 3.5 µm, m = 0…60 공식 r 중 하나, $2\pi n r\approx53$을 넘게 공식은 첫 1% 아래에서 멈춤
C 다층 3.2 / 1.5 / 2.3 / 1.5, res 25 공식 edge_emitter_2D.py —
C kz 0.02 간격, 전체 power가 최대의 2% 아래일 때까지 공식 값 간격이 넓으면 guided 봉우리를 놓친다

source source 파형과 스펙트럼(1000 nm, fwidth 0.1 fcen. B는 0.05). 효율은 중심 주파수 하나에서 잰다.

강의 노트북과의 차이: 강의 범위 밖이다. 10_sources의 세 노트는 각각 공식 조건 전체(21 높이 × 2 좌표계 res 80, r 네 개 × m 수백, kz 76점)를 돌렸다. 이 글은 A의 3D를 세 높이·res 40으로 줄이고, B는 r 하나에서 공식 종료 규칙과 m = 60까지 합한 값을 같은 그림에 놓는다.

4. 코드 따라가기

읽는 순서: 단위·파라미터 → 재료·구조 → source → Simulation·경계 → monitor → 실행·종료 → 후처리. 이번 글의 핵심은 ⑦의 분모다.

① 단위와 파라미터 — 어떤 숫자를 고정하는가

WL, FREQ, N_L = 1.0, 1.0, 2.4
T_L = 0.7 * WL / N_L                      # layer thickness
DPML, DAIR, L = 0.5, 1.0, 6.0             # PML, air above the layer, lateral size of the collection surface
HEIGHTS = np.round(np.linspace(0.1, 0.9, 9), 3)      # dipole height above the ground plane, fraction of T_L
DKZ, KZ_TOL = 0.02, 0.02                  # part C: kz step and stop when the total power falls below 2 % of its max
  • 무엇: 층과 수집면, 높이 sweep, kz 간격.
  • 왜: 층 두께 0.7λ/n은 guided mode가 하나 남짓 들어가는 두께다. 높이를 바꾸면 쌍극자와 거울 image의 간섭이 바뀌어 방출 방향과 양이 둘 다 변한다.
  • 틀리면: 수집면 L이 좁으면 옆으로 비스듬히 나간 빛이 PML로 가 버려 분자가 작아진다.

② 재료와 구조 — 층 하나와 거울

mp.Block(material=mp.Medium(index=N_L), center=mp.Vector3(0, 0, -0.5 * sz + 0.5 * T_L), size=mp.Vector3(mp.inf, mp.inf, T_L))
boundary_layers=[mp.PML(DPML, direction=mp.R), mp.PML(DPML, direction=mp.Z, side=mp.High)]     # bottom: no PML = ground plane
  • 무엇: 셀 바닥에 붙은 무한 층. 바닥 벽에는 PML이 없다.
  • 왜: 11·13편과 같은 규칙으로 PML 없는 벽은 완전도체 거울이다. 위쪽과 옆쪽만 연다.
  • 틀리면: 공식 docstring은 “metallic ground plane”이라 하지만 코드에 금속 블록은 없다. 거울은 경계 조건이다. 바닥에도 PML을 두면 거울이 사라지고 효율이 달라진다.

③ Source — 같은 쌍극자의 세 표현

mp.Source(src, component=mp.Er, center=mp.Vector3(1.5 / res, 0, z_src))      # cylindrical, m = -1 (13편: in-plane dipole)
mp.Source(src, component=mp.Ex, center=mp.Vector3(0, 0, z_src))              # 3D with Mirror(X, -1), Mirror(Y)
mp.Source(src, component=mp.Ez, center=SRC_C)                                 # 2D + kz: a line current along z with phase exp(i kz z)
  • 무엇: A의 수평 쌍극자를 cylindrical에서는 Er(m = −1), 3D에서는 Ex로. C는 절단면 레이저의 z 방향 쌍극자.
  • 왜: 2D 셀의 점원은 z로 무한한 선전류다. 그 선전류에 $e^{ik_zz}$ 위상을 주고 kz에 대해 적분하면 점광원이 된다. 10편의 1D Bloch run과 같은 생각을 한 차원 올린 것이다.
  • 틀리면: cylindrical에서 r = 0에 Er을 두면 축의 Yee 격자에 Er이 없어 결과가 틀린다(meep #2704). 1.5 픽셀 비킨다.

④ Simulation과 경계 — 좌표계와 kz

mp.Simulation(..., dimensions=mp.CYLINDRICAL, m=-1)                                                   # A, cylindrical
mp.Simulation(..., symmetries=[mp.Mirror(mp.X, phase=-1), mp.Mirror(mp.Y)])                          # A, 3D: 1/4 of the cell
mp.Simulation(..., k_point=mp.Vector3(0, 0, kz), kz_2d="real/imag")                                   # C: 2D cell, out-of-plane wavevector
  • 무엇: 같은 물리를 세 좌표계로. C는 2D 셀에 k_point의 z 성분과 kz_2d.
  • 왜: kz_2d="real/imag"는 kz가 있는 2D 계산을 실수 field 두 벌로 푸는 방법이다. 세 표현(real/imag, complex, 3d)이 같다는 것은 10_sources의 kz_2d 노트(18편 예정)에서 확인했다.
  • 틀리면: 3D 대칭 위상을 둘 다 +1로 두면 다른 parity의 source를 계산한다(11편).

⑤ Monitor — 분자는 공기 쪽 열린 면

mp.FluxRegion(center=mp.Vector3(0.5 * L, 0, 0.5 * sz - DPML), size=mp.Vector3(L, 0, 0))                   # top
mp.FluxRegion(center=mp.Vector3(L, 0, 0.5 * sz - DPML - 0.5 * DAIR), size=mp.Vector3(0, 0, DAIR))         # side, air only
sim.run(mp.dft_ldos(FREQ, 0, 1), until_after_sources=...)                                                  # denominator data
  • 무엇: 위와 옆(공기 높이만)의 flux. 3D는 옆면 네 개, 음의 면은 weight=-1. 동시에 dft_ldos를 step function으로 넣어 분모 데이터를 모은다.
  • 왜: 옆면을 층 높이까지 내리면 층에 갇혀 옆으로 가는 빛까지 “추출”로 센다. 공기 높이만 잡는다.
  • 틀리면: B의 cylindrical 셀(r 20 µm)에서는 층에 갇힌 빛이 PML 직전의 옆면을 지나간다. 공식 B 코드는 옆면을 공기층 높이에 두지만, 층의 감쇠 꼬리가 거기에 닿는다. 이것이 §5의 되튐과 관련이 있다.

⑥ 실행 — 급수와 종료

for m in range(M_MAX + 1):                                    # B: every m up to 60, then decide where to cut afterwards
    rad, src = dipole_in_slab(R_SRC, m)
m_stop = next(m for m in range(1, M_MAX + 1) if rel[m] < 1e-2)    # the official rule, applied to the same data

while True:                                                    # C: kz = 0, 0.02, 0.04, ...
    ...
    if dflux > dmax: dmax = dflux
    elif dflux / dmax < KZ_TOL: break
  • 무엇: B는 공식처럼 도중에 멈추지 않고 m = 60까지 다 돌린 뒤, 같은 데이터에 공식 규칙을 적용해 비교한다. C는 공식 규칙 그대로.
  • 왜: 종료 규칙이 맞는지 보려면 규칙 뒤의 항을 실제로 봐야 한다.
  • 틀리면: B에서 공식 규칙만 쓰면 m_stop 이후를 볼 수 없어 되튐을 모른다.

⑦ 후처리 — 분모와 급수

p_tot = -np.real(sim.ldos_Fdata[0] * np.conj(sim.ldos_Jdata[0])) * dV     # dV: 2*pi*r/res**2 (cyl), 1/res**3 (3D), 1/res**2 (2D)
eff = p_air / p_tot
eff_series = np.cumsum(w * rads) / np.cumsum(w * srcs)                    # w = 1 for m = 0, 2 for m > 0
eff_edge = (a_kz[0] + 2 * a_kz[1:].sum()) / (d_kz[0] + 2 * d_kz[1:].sum())
  • 무엇: 분모는 source 한 개의 일. 급수는 분자와 분모를 각각 더한 뒤 나눈다.
  • 왜: 항마다 효율을 내서 평균하면 안 된다. power가 큰 항이 효율을 정해야 한다.
  • 틀리면: $\Delta V$를 빼먹으면 cylindrical과 3D가 수백 배 다르다. cylindrical의 $2\pi r$은 source가 축을 도는 고리라는 뜻이다.

함정: 11편의 Purcell 인자는 같은 좌표계 두 run의 비율이라 $\Delta V$가 상쇄됐다. 추출 효율은 flux(물리 단위)와 source 일의 비율이라 $\Delta V$가 상쇄되지 않는다. 좌표계를 바꾸면 이 인자를 같이 바꿔야 한다.

5. 결과

height 파트 A. 왼쪽: 쌍극자 높이에 따른 추출 효율. cylindrical res 80(파랑), res 40(하늘색), 3D res 40(빨간 마름모). 오른쪽: h = 0.5의 log|Er|. 흰 사각형이 층이고, 층을 따라 멀리까지 가는 빛이 갇힌 몫이다.

h CYL res 80 CYL res 40 3D res 40 노트: 3D res 80
0.1 0.5230 0.5494 0.5475 —
0.2 0.5038 0.5214 — —
0.3 0.4645 0.4735 — —
0.4 0.4050 0.4014 — —
0.5 0.3232 0.3018 0.3505 0.3369
0.6 0.2213 0.1805 — —
0.7 0.1259 0.0891 — —
0.8 0.0915 0.1095 — —
0.9 0.1745 0.2681 0.2607 —

m series 파트 B. 왼쪽: r = 3.5 µm 쌍극자의 m 항별 방사 power(그때까지의 최대로 나눔). 빨간 점선이 공식 종료 기준 1%, 회색 점선이 $m=2\pi nr$. 오른쪽: m을 어디서 끊느냐에 따른 효율. 보라 점선은 같은 층에서 축 위 쌍극자의 효율.

계산 m 범위 추출 효율
축 위 쌍극자 (r = 0.03 µm, m = 1) 1 run 0.3636
r = 3.5 µm, 공식 규칙(첫 1% 미만) 0…32 0.6323
r = 3.5 µm, m = 60까지 0…60 0.3616
공식 규칙 뒤의 되튐 m = 41에서 최대의 0.38 —
노트(10_sources): 공식 문서 CYL / 3D 기준 — 0.320–0.324 / 0.334

kz 파트 C. 왼쪽: kz마다의 전체 방출(회색)과 공기로 나간 몫(파랑). 점선은 공기, 클래딩, 활성층의 빛선(light line). 오른쪽: kz를 어디까지 더했느냐에 따른 효율.

항목 값
kz 점 수 76 (0~1.50, 간격 0.02)
마지막 kz의 전체 power / 최대 0.0189
추출 효율 (kz 적분) 22.375%
kz = 0 하나만 (2D 선전류) 32.91%
노트(10_sources) 22.375%, 76점

animation 파트 C, kz = 0의 짧은 펄스. 활성층의 쌍극자(빨강)에서 나온 빛 대부분이 다층을 따라 기판 쪽으로 가고, 일부가 절단면을 지나 공기로 나간다.

예측과 비교

물리량 내 예측 (§2) 시뮬레이션 판정
추출 효율(A, h = 0.5) 0.3 근처 0.323 (CYL res 80) ✅
높이 의존 거울에서 멀수록 변한다 0.52 → 0.09(h 0.8) → 0.17 ✅
CYL res 40 vs 80 1% 안 h ≤ 0.4에서 2~5%, h ≥ 0.6에서 18~54% ❌
3D vs CYL 2% 안 res 40: h 0.1 0.4%, h 0.5 16%, h 0.9 2.7% ❌
축 위 쌍극자(B) 0.3 근처 0.364 ✅
B: 공식 종료 규칙 sum-to-60과 다르다 0.632 vs 0.362 ✅
C: 필요한 kz 수 70~80 76 ✅
C: 추출 효율 22% 근처 22.375% ✅

여덟 예측 중 여섯이 맞았고, 틀린 두 개가 모두 해상도 문제였다. 층 두께 0.292 µm는 res 40에서 11.7칸이다. 쌍극자 높이를 층 두께의 비율로 주면 격자에 맞춰 반올림되고, 위쪽 공기 계면 근처(h ≥ 0.6)에서는 field가 급하게 변해 한두 칸의 차이가 효율을 크게 바꾼다. res 40에서 CYL과 3D가 h = 0.5에서 16% 다른 것도 같은 원인으로 본다. 노트의 res 80 값은 CYL 0.323, 3D 0.337로 차이가 1.4%까지 줄었다. 이 층에는 res 80이 필요하다. B는 노트와 소수 넷째 자리까지 같다. 공식 규칙은 m = 32에서 멈춰 0.632를 내지만, 그 뒤 m = 41 근처에서 항이 다시 커진다. 이 항들은 source의 일(분모)이 매우 크고 공기로 나간 몫(분자)은 작다. 층에 갇혀 반지름 방향으로 가는 빛은 쌍극자에서 r만큼 떨어진 곳에서 둘레 $2\pi r$에 $n_{\mathrm{eff}}$배의 파장이 들어가는 m, 즉 $m\approx2\pi n_{\mathrm{eff}}r$ 근처에 실린다. 이 m을 빼면 분모의 대부분이 빠지므로 효율이 두 배로 나온다. m = 60까지 더한 0.362는 축 위 쌍극자의 0.364와 0.5% 안에서 같다. 무한한 층에서는 쌍극자의 가로 위치가 효율을 바꾸지 않아야 하므로 이 일치가 급수를 맞게 끊었다는 검산이다. C에서 kz = 0 하나(2D 선전류)는 32.9%를 주지만 적분하면 22.4%다. kz가 공기의 빛선 k₀를 넘으면 공기로는 빛이 못 나가고(파랑이 0) 다층 안의 guided 방출만 남는다(회색 봉우리). 2D 계산 하나로 3D 소자의 추출 효율을 말하면 이 몫이 빠진다.

수렴성

변수 값 결과 비고
A 해상도 CYL 40 / 80 (노트 80) h 0.5: 0.302 / 0.323 층이 12칸뿐인 res 40은 부족
A 좌표계 CYL 40 vs 3D 40; 노트 CYL 80 vs 3D 80 16% / 1.4% (h 0.5) 해상도를 올리면 두 좌표계가 만난다
B m 범위 0…32 / 0…60 0.632 / 0.362 마지막 항 2e-8
C kz 범위 0 / 0…1.50 32.9% / 22.4% tail 0.019

주장할 수 있는 것 / 없는 것

  • 할 수 있는 것: 이 층(n 2.4, 0.7λ/n, 거울 위)에서 수평 쌍극자의 추출 효율은 높이에 따라 0.52에서 0.09까지 변하고, h = 0.5에서 res 80의 cylindrical 값은 0.323이다. 축에서 3.5 µm 떨어진 쌍극자도 m을 guided 빛 너머(60)까지 더하면 축 위와 같은 0.36이 된다. 절단면 레이저(z 쌍극자, 0.5 µm)의 추출 효율은 kz 적분으로 22.4%다.
  • 할 수 없는 것: res 40의 높이 곡선(특히 h ≥ 0.6). 3D 값의 수렴(이 글은 res 40만 돌렸다). B의 0.36이 A의 0.32와 다른 이유(셀 크기 20 vs 6 µm, 해상도 50 vs 80, 대역폭이 다르다)를 하나로 정하는 것. 열린 면이라 갇힌 빛이 흡수 없이 어디로 가는지의 에너지 수지.

6. 흔한 실수

증상 원인 고치는 법
효율이 1보다 큼 또는 수백 배 다름 분모의 $\Delta V$ 누락, 좌표계에 맞지 않는 $\Delta V$ cyl $2\pi r/\mathrm{res}^2$, 3D $1/\mathrm{res}^3$, 2D $1/\mathrm{res}^2$
분모를 진공 source power로 둠 거울·층이 방출량을 바꾼다는 것을 잊음 같은 run의 dft_ldos로 잰다
효율이 너무 큼 옆면 monitor를 층 높이까지 내림 옆면은 공기 높이만
CYL이 축 근처에서 틀림 Er을 r = 0에 둠 1.5 픽셀 offset
m 급수 효율이 크게 다름 첫 1% 교차에서 멈춤 guided 빛의 $m\approx2\pi nr$ 너머까지 보고 정한다
kz 적분이 작게 나옴 kz > 0 항을 두 배로 세지 않음 ±kz 대칭, $w=2$
3D가 CYL과 2배 다름 3D 대칭 위상 틀림 Ex는 Mirror(X, −1)

7. 직접 해보기

바꿀 것 예상 변화 확인할 수치
A의 층 두께 0.7λ/n → 0.4λ/n guided mode가 줄어 효율이 오른다 η(h = 0.5)
A를 수직 쌍극자(Ez, m = 0)로 위로 덜 나가 효율이 크게 준다 η
B의 r = 6.7, 9.5 µm 되튐이 더 큰 m으로 간다 m_stop, 되튐 위치
C를 x·y 편광으로 편광마다 다른 효율 η
11개 쌍극자 디스크(disc_extraction_efficiency.py) 노트: 0.932, m 93개 run η, 마지막 m의 몫

8. 전체 코드

code/extraction_efficiency.py 전체 (클릭하여 펼치기) 
"""Meep Example 14 - A point source in a thin film: the share that escapes into air (light-extraction efficiency).

Post 11 measured how much a dipole emits (LDOS); post 13 split a body of revolution into m runs. An LED asks
the ratio of the two: of all the power a dipole in the emitting layer puts out, how much reaches the air?
    extraction efficiency = P_air (flux through an open surface in air) / P_total (source work from dft_ldos)
  A. Official extraction_eff_ldos.py: a dipole in a dielectric layer (n = 2.4, t = 0.7 wl / n) on a ground
     plane, efficiency vs dipole height, in cylindrical coordinates (Er, m = -1) at resolution 40 and 80 and in
     3D (Ex) at resolution 40. The denominator needs the voxel volume of each coordinate system.
  B. Official point_dipole_cyl.py: the same slab, a dipole 3.5 um off the axis = an m series. The official stop
     rule (first m whose radiated flux < 1 % of the running max) is compared with summing far beyond it: the
     slab-guided light reaches the side monitor through high m and the series rebounds.
  C. Official edge_emitter_2D.py: a z-dipole 0.5 um inside the cleaved facet of a multilayer laser stack.
     The 3D problem is a 2D cross-section plus an integral over the out-of-plane wavevector kz.
MPI-safe: collective calls on every rank, figures on the master only.

Run:  mpirun -np 4 python extraction_efficiency.py      (~40 min)
Out:  00_source.png, 01_layout.png, 02_layout_edge.png, 03_height.png, 04_m_series.png, 05_kz.png,
      06_field.png, 07_anim_edge.gif, result.json   (-> ../assets/14/)
"""
import json
import math
import os
import sys
import time

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import meep as mp

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from blogfig import Label, animate_fields, annotated_layout, record_frames, source_figure   # noqa: E402

HERE = os.path.dirname(os.path.abspath(__file__))
OUT = os.path.join(HERE, "..", "assets", "14")
os.makedirs(OUT, exist_ok=True)
MASTER = mp.am_master()
t_all = time.time()


def say(*a):
    if MASTER:
        print(*a, flush=True)


def orient_rz(arr, nr):
    arr = np.asarray(arr)
    if arr.ndim == 2 and abs(arr.shape[1] - nr) < abs(arr.shape[0] - nr):
        return arr.T
    return arr


def source_work(sim, dV):
    """Total power emitted by the point source: -Re(F J*) dV from the dft_ldos data."""
    return float(-np.real(sim.ldos_Fdata[0] * np.conj(sim.ldos_Jdata[0])) * dV)


# ================================================================ A. dipole in a layer on a ground plane: CYL vs 3D
WL, FREQ, N_L = 1.0, 1.0, 2.4
T_L = 0.7 * WL / N_L                      # layer thickness
DPML, DAIR, L = 0.5, 1.0, 6.0             # PML, air above the layer, lateral size of the collection surface
TOL = 1e-8
HEIGHTS = np.round(np.linspace(0.1, 0.9, 9), 3)      # dipole height above the ground plane, fraction of T_L
H3D = (0.1, 0.5, 0.9)


def layer(sz):
    return [mp.Block(material=mp.Medium(index=N_L), center=mp.Vector3(0, 0, -0.5 * sz + 0.5 * T_L), size=mp.Vector3(mp.inf, mp.inf, T_L))]


def eff_cyl(h, res, want=False):
    sr, sz = L + DPML, T_L + DAIR + DPML
    src_pt = mp.Vector3(1.5 / res, 0, -0.5 * sz + h * T_L)          # Er at r = 0 is undefined on the Yee grid (meep #2704)
    sim = mp.Simulation(resolution=res, cell_size=mp.Vector3(sr, 0, sz), dimensions=mp.CYLINDRICAL, m=-1,
                        boundary_layers=[mp.PML(DPML, direction=mp.R), mp.PML(DPML, direction=mp.Z, side=mp.High)],   # bottom: no PML = ground plane
                        sources=[mp.Source(mp.GaussianSource(FREQ, fwidth=0.1 * FREQ), component=mp.Er, center=src_pt)], geometry=layer(sz))
    flux = sim.add_flux(FREQ, 0, 1, mp.FluxRegion(center=mp.Vector3(0.5 * L, 0, 0.5 * sz - DPML), size=mp.Vector3(L, 0, 0)),
                        mp.FluxRegion(center=mp.Vector3(L, 0, 0.5 * sz - DPML - 0.5 * DAIR), size=mp.Vector3(0, 0, DAIR)))
    dft = sim.add_dft_fields([mp.Er], FREQ, 0, 1, center=mp.Vector3(0.5 * L, 0, -0.5 * DPML), size=mp.Vector3(L, 0, sz - DPML)) if want else None
    if want:
        annotated_layout(sim, os.path.join(OUT, "01_layout.png"), dpml=DPML, figsize=(11, 3.6), axis_step=1.0, unit="um",
                         title="part A, cylindrical (r, z) cell: dipole in a layer (n = 2.4) on a ground plane; x = r, y = z",
                         params_text=f"wl={WL} um, res={res}\nt = 0.7 wl/n = {T_L:.3f} um", params_xy=(3.6, 0.33), pml_xy=(6.05, -0.6),
                         decay_point=(src_pt.x, src_pt.z), decay_text_xy=(1.8, -0.45),
                         labels=[Label("layer n = 2.4 (bottom edge: PEC ground plane, no PML)", (2.5, -0.75), (1.8, -0.2), step=2, color="black"),
                                 Label("Er dipole at r = 1.5 px, height h", (src_pt.x, src_pt.z), (1.8, 0.05), step=3, color="red"),
                                 Label("numerator: flux through top + outer r (air only)", (4.0, 0.5 * sz - DPML), (3.6, -0.2), step=5, color="blue")])
    sim.run(mp.dft_ldos(FREQ, 0, 1), until_after_sources=mp.stop_when_fields_decayed(20, mp.Er, src_pt, TOL))
    p_air = float(mp.get_fluxes(flux)[0])
    p_tot = source_work(sim, 2 * np.pi * src_pt.x / res ** 2)         # CYL voxel: 2 pi r dr dz
    er = orient_rz(sim.get_dft_array(dft, mp.Er, 0), int(round(L * res))) if want else None
    sim.reset_meep()
    return p_air / p_tot, er, sz


def eff_3d(h, res):
    sxy, sz = L + 2 * DPML, T_L + DAIR + DPML
    src_pt = mp.Vector3(0, 0, -0.5 * sz + h * T_L)
    sim = mp.Simulation(resolution=res, cell_size=mp.Vector3(sxy, sxy, sz), symmetries=[mp.Mirror(mp.X, phase=-1), mp.Mirror(mp.Y)],
                        boundary_layers=[mp.PML(DPML, direction=mp.X), mp.PML(DPML, direction=mp.Y), mp.PML(DPML, direction=mp.Z, side=mp.High)],
                        sources=[mp.Source(mp.GaussianSource(FREQ, fwidth=0.1 * FREQ), component=mp.Ex, center=src_pt)], geometry=layer(sz))
    zc = 0.5 * sz - DPML - 0.5 * DAIR
    flux = sim.add_flux(FREQ, 0, 1, mp.FluxRegion(center=mp.Vector3(0, 0, 0.5 * sz - DPML), size=mp.Vector3(L, L, 0)),
                        mp.FluxRegion(center=mp.Vector3(0.5 * L, 0, zc), size=mp.Vector3(0, L, DAIR)),
                        mp.FluxRegion(center=mp.Vector3(-0.5 * L, 0, zc), size=mp.Vector3(0, L, DAIR), weight=-1.0),
                        mp.FluxRegion(center=mp.Vector3(0, 0.5 * L, zc), size=mp.Vector3(L, 0, DAIR)),
                        mp.FluxRegion(center=mp.Vector3(0, -0.5 * L, zc), size=mp.Vector3(L, 0, DAIR), weight=-1.0))
    sim.run(mp.dft_ldos(FREQ, 0, 1), until_after_sources=mp.stop_when_fields_decayed(20, mp.Ex, src_pt, TOL))
    p_air = float(mp.get_fluxes(flux)[0])
    p_tot = source_work(sim, 1 / res ** 3)                                # 3D voxel
    sim.reset_meep()
    return p_air / p_tot


t_a = time.time()
effA = {"cyl40": [], "cyl80": []}
er_map, sz_A = None, None
for h in HEIGHTS:
    effA["cyl40"].append(eff_cyl(h, 40)[0])
    e80, er, sz = eff_cyl(h, 80, want=(h == 0.5))
    effA["cyl80"].append(e80)
    if er is not None:
        er_map, sz_A = er, sz
say("A (cyl): " + "; ".join(f"h {h:.1f}: res40 {a:.4f}, res80 {b:.4f}" for h, a, b in zip(HEIGHTS, effA["cyl40"], effA["cyl80"])) + f"; {time.time() - t_a:.0f} s")
t_a3 = time.time()
eff3 = {h: eff_3d(h, 40) for h in H3D}
say("A (3D, res 40): " + "; ".join(f"h {h}: {v:.4f} (cyl40 {effA['cyl40'][list(HEIGHTS).index(h)]:.4f}, cyl80 {effA['cyl80'][list(HEIGHTS).index(h)]:.4f})" for h, v in eff3.items()) + f"; {time.time() - t_a3:.0f} s")
if MASTER:
    source_figure(FREQ, 0.1 * FREQ, os.path.join(OUT, "00_source.png"), wl_scale=1000.0, wl_unit="nm", time_unit="um/c")

# ================================================================ B. off-axis dipole in the slab: the m series and when to stop
t_b = time.time()
RES_B, R_CELL, PML_B, PAD_B = 50, 20.0, 1.0, 1.0
M_MAX = 60
R_SRC = 3.5


def dipole_in_slab(rpos, m):
    sr, sz = R_CELL + PML_B, T_L + PAD_B + PML_B
    src_pt = mp.Vector3(rpos, 0, -0.5 * sz + 0.5 * T_L)
    sim = mp.Simulation(resolution=RES_B, cell_size=mp.Vector3(sr, 0, sz), dimensions=mp.CYLINDRICAL, m=m, force_complex_fields=True,
                        boundary_layers=[mp.PML(PML_B, direction=mp.R), mp.PML(PML_B, direction=mp.Z, side=mp.High)],
                        sources=[mp.Source(mp.GaussianSource(FREQ, fwidth=0.05 * FREQ), component=mp.Er, center=src_pt)], geometry=layer(sz))
    flux = sim.add_flux(FREQ, 0, 1, mp.FluxRegion(center=mp.Vector3(0.5 * R_CELL, 0, 0.5 * sz - PML_B), size=mp.Vector3(R_CELL, 0, 0)),
                        mp.FluxRegion(center=mp.Vector3(R_CELL, 0, 0.5 * sz - PML_B - 0.5 * PAD_B), size=mp.Vector3(0, 0, PAD_B)))
    sim.run(mp.dft_ldos(FREQ, 0, 1), until_after_sources=mp.stop_when_dft_decayed(tol=1e-4))
    rad = float(mp.get_fluxes(flux)[0])
    src = source_work(sim, 2 * np.pi * rpos / RES_B ** 2)
    sim.reset_meep()
    return rad, src


r_ax = 1.5 / RES_B
rad_ax, src_ax = dipole_in_slab(r_ax, 1)
eff_axis = rad_ax / src_ax
say(f"B: dipole on the axis (m = 1, r = {r_ax:.2f}): extraction {eff_axis:.4f}")
rads, srcs = [], []
for m in range(M_MAX + 1):
    rad, src = dipole_in_slab(R_SRC, m)
    rads.append(rad); srcs.append(src)
    if m % 5 == 0:
        say(f"B: r {R_SRC}, m = {m}: radiated {rad:.4e}, source {src:.4e}; {time.time() - t_b:.0f} s")
rads, srcs = np.array(rads), np.array(srcs)
w = np.where(np.arange(M_MAX + 1) == 0, 1, 2)                                  # +-m give the same power: count m > 0 twice
running_max = np.maximum.accumulate(rads)
rel = rads / running_max
m_stop = int(next(m for m in range(1, M_MAX + 1) if rel[m] < 1e-2))             # official rule: first m > 0 below 1 % of the running max
eff_series = np.cumsum(w * rads) / np.cumsum(w * srcs)
eff_official = float(eff_series[m_stop]); eff_full = float(eff_series[-1])
rebound = float(rel[m_stop:].max())
m_rebound = int(m_stop + np.argmax(rel[m_stop:]))
say(f"B: official stop at m = {m_stop} (radiated/max {rel[m_stop]:.2e}) -> efficiency {eff_official:.4f}; after the stop the series rebounds to "
    f"{rebound:.3f} of the max at m = {m_rebound}; summed to m = {M_MAX}: efficiency {eff_full:.4f} (last term {rel[-1]:.1e}); {time.time() - t_b:.0f} s")

# ================================================================ C. cleaved-facet edge emitter: 2D cross-section + kz integral
t_c = time.time()
RES_C, CLAD, ACT, SUB, PML_C, AIR_C, SIDE = 25, 0.5, 0.3, 1.0, 0.5, 1.0, 3.0
N_SUB, N_CLAD, N_ACT = 3.2, 1.5, 2.3
DKZ, KZ_TOL, POS_C = 0.02, 0.02, 0.5
CX = PML_C + SIDE + AIR_C + PML_C
CY = PML_C + SUB + CLAD + ACT + CLAD + AIR_C + PML_C
SRC_C = mp.Vector3(-0.5 * CX + PML_C + SIDE - POS_C, -0.5 * CY + PML_C + SUB + CLAD + 0.5 * ACT)


def stack():
    x0 = -0.5 * CX + 0.5 * (PML_C + SIDE); wx = PML_C + SIDE; y = -0.5 * CY
    out = []
    for th, n in ((PML_C + SUB, N_SUB), (CLAD, N_CLAD), (ACT, N_ACT), (CLAD, N_CLAD)):
        out.append(mp.Block(material=mp.Medium(index=n), center=mp.Vector3(x0, y + 0.5 * th), size=mp.Vector3(wx, th, mp.inf))); y += th
    return out


def edge_sim(kz, fwidth=0.1 * FREQ, monitors=True):
    sim = mp.Simulation(resolution=RES_C, cell_size=mp.Vector3(CX, CY), k_point=mp.Vector3(0, 0, kz), kz_2d="real/imag",
                        sources=[mp.Source(mp.GaussianSource(FREQ, fwidth=fwidth), component=mp.Ez, center=SRC_C)], geometry=stack(),
                        boundary_layers=[mp.PML(PML_C)])
    flux = None
    if monitors:
        flux = sim.add_flux(FREQ, 0, 1,
                            mp.FluxRegion(center=mp.Vector3(0, 0.5 * CY - PML_C), size=mp.Vector3(CX - 2 * PML_C, 0)),                 # top
                            mp.FluxRegion(center=mp.Vector3(0.5 * CX - PML_C, 0), size=mp.Vector3(0, CY - 2 * PML_C)),                 # right (in front of the facet)
                            mp.FluxRegion(center=mp.Vector3(0.5 * CX - PML_C - 0.5 * AIR_C, -0.5 * CY + PML_C), size=mp.Vector3(AIR_C, 0), weight=-1.0))   # bottom of the air gap
    return sim, flux


kzs, d_kz, a_kz = [], [], []
nkz, dmax = 0, 0.0
while True:
    kz = nkz * DKZ
    sim, flux = edge_sim(kz)
    if nkz == 0:
        annotated_layout(sim, os.path.join(OUT, "02_layout_edge.png"), dpml=PML_C, figsize=(6.4, 6.0), axis_step=1.0, unit="um",
                         title="part C: cleaved facet of a laser stack (2D x-y); the stack is uniform along z",
                         params_text=f"res={RES_C}, kz step {DKZ}\nsub 3.2 / clad 1.5 / act 2.3", params_xy=(-2.4, 2.25), pml_xy=(-2.4, -2.2), decay_point=None,
                         labels=[Label("Ez dipole 0.5 um inside the facet", (SRC_C.x, SRC_C.y), (-2.4, 1.5), step=3, color="red"),
                                 Label("active layer n = 2.3 between claddings", (-1.5, SRC_C.y), (-2.4, 0.8), step=2, color="black"),
                                 Label("air flux: top + front + under the gap", (1.9, 0.6), (-0.3, 1.9), step=5, color="blue")])
    sim.run(mp.dft_ldos(FREQ, 0, 1), until_after_sources=mp.stop_when_fields_decayed(25, mp.Ez, SRC_C, 1e-6))
    dflux = source_work(sim, 1 / RES_C ** 2)            # 2D: a line current, pixel area
    aflux = float(mp.get_fluxes(flux)[0])
    sim.reset_meep()
    kzs.append(kz); d_kz.append(dflux); a_kz.append(aflux)
    nkz += 1
    if dflux > dmax:
        dmax = dflux
    elif dflux / dmax < KZ_TOL:
        break
kzs, d_kz, a_kz = map(np.array, (kzs, d_kz, a_kz))
eff_edge = float((a_kz[0] + 2 * a_kz[1:].sum()) / (d_kz[0] + 2 * d_kz[1:].sum()))
eff_kz0 = float(a_kz[0] / d_kz[0])
kz_cut = N_ACT * FREQ
say(f"C: {len(kzs)} kz points up to {kzs[-1]:.2f} (tail {d_kz[-1] / dmax:.4f}); extraction {100 * eff_edge:.3f} % (kz = 0 alone: {100 * eff_kz0:.2f} %); {time.time() - t_c:.0f} s")

# GIF: kz = 0, short pulse, monitor-free
sim_g, _ = edge_sim(0.0, fwidth=0.4 * FREQ, monitors=False)
sim_g.init_sim()
vol = mp.Volume(center=mp.Vector3(), size=mp.Vector3(CX - 2 * PML_C, CY - 2 * PML_C))
eps_g = sim_g.get_array(vol=vol, component=mp.Dielectric)
t0 = 5 / (0.4 * FREQ)
frames, times = record_frames(sim_g, vol, mp.Ez, t_start=t0 - 2 / (0.4 * FREQ), t_end=t0 + 9.0, n_frames=60)
sim_g.reset_meep()

# ================================================================ figures
if MASTER:
    fig, ax = plt.subplots(1, 2, figsize=(12, 4.3), gridspec_kw={"width_ratios": [1.4, 1]})
    ax[0].plot(HEIGHTS, effA["cyl80"], "o-", color="tab:blue", label="cylindrical, res 80 (official)")
    ax[0].plot(HEIGHTS, effA["cyl40"], "s--", color="tab:cyan", label="cylindrical, res 40")
    ax[0].plot(list(H3D), [eff3[h] for h in H3D], "D", color="tab:red", ms=8, label="3D Cartesian, res 40")
    ax[0].set_xlabel("dipole height above the ground plane / layer thickness"); ax[0].set_ylabel("extraction efficiency into air")
    ax[0].set_title("dipole in a 0.29 um layer (n = 2.4) on a mirror", fontsize=9); ax[0].grid(alpha=0.3); ax[0].legend(fontsize=8)
    ext = [0, L, -0.5 * sz_A, 0.5 * sz_A - DPML]
    ax[1].imshow(np.log10(np.abs(er_map) + 1e-12).T, extent=ext, origin="lower", cmap="inferno", aspect="auto")
    ax[1].add_patch(plt.Rectangle((0, -0.5 * sz_A), L, T_L, fill=False, color="w", lw=1))
    ax[1].set_xlabel("r [um]"); ax[1].set_ylabel("z [um]"); ax[1].set_title("log10 |Er|, h = 0.5 (res 80): much of the light stays in the layer", fontsize=9)
    fig.tight_layout(); fig.savefig(os.path.join(OUT, "03_height.png"), dpi=150); plt.close(fig)

    ms = np.arange(M_MAX + 1)
    fig, ax = plt.subplots(1, 2, figsize=(12, 4.3))
    ax[0].semilogy(ms, rel, "o-", ms=3, color="tab:blue", label="radiated(m) / running max")
    ax[0].axhline(1e-2, color="crimson", ls="--", lw=1, label="official stop: 1 %")
    ax[0].axvline(m_stop, color="crimson", ls=":", lw=1); ax[0].text(m_stop + 0.5, 2e-1, f"stop at m = {m_stop}", color="crimson", fontsize=8)
    ax[0].plot(m_rebound, rebound, "*", color="tab:orange", ms=12, label=f"rebound {rebound:.2f} at m = {m_rebound}")
    ax[0].axvline(2 * np.pi * N_L * R_SRC, color="gray", ls="-.", lw=1); ax[0].text(2 * np.pi * N_L * R_SRC - 14, 2e-4, "m = 2 pi n r (guided in the slab)", fontsize=8, color="gray")
    ax[0].set_xlabel("azimuthal order m"); ax[0].set_ylabel("radiated power of the m term (relative)"); ax[0].set_title(f"dipole at r = {R_SRC} um in the slab", fontsize=9); ax[0].grid(alpha=0.3, which="both"); ax[0].legend(fontsize=7)
    ax[1].plot(ms, eff_series, "-", color="tab:green"); ax[1].axvline(m_stop, color="crimson", ls=":", lw=1)
    ax[1].axhline(eff_axis, color="tab:purple", ls="--", lw=1, label=f"dipole on the axis: {eff_axis:.3f}")
    ax[1].plot(m_stop, eff_official, "o", color="crimson", label=f"official stop: {eff_official:.3f}")
    ax[1].plot(M_MAX, eff_full, "o", color="tab:green", label=f"summed to m = {M_MAX}: {eff_full:.3f}")
    ax[1].set_xlabel("m included up to"); ax[1].set_ylabel("extraction efficiency"); ax[1].set_title("the efficiency depends on where the series is cut", fontsize=9); ax[1].grid(alpha=0.3); ax[1].legend(fontsize=7)
    fig.tight_layout(); fig.savefig(os.path.join(OUT, "04_m_series.png"), dpi=150); plt.close(fig)

    fig, ax = plt.subplots(1, 2, figsize=(12, 4.3))
    ax[0].plot(kzs, d_kz / d_kz.max(), "o-", ms=3, color="tab:gray", label="total (dft_ldos)")
    ax[0].plot(kzs, a_kz / d_kz.max(), "o-", ms=3, color="tab:blue", label="into air")
    for kc, lab in ((FREQ, "kz = k0 (air light line)"), (N_CLAD * FREQ, "1.5 k0"), (N_ACT * FREQ, "2.3 k0")):
        ax[0].axvline(kc, color="k", ls=":", lw=0.8); ax[0].text(kc + 0.02, 0.9, lab, fontsize=7, rotation=90, va="top")
    ax[0].set_xlabel("kz [2 pi / um]"); ax[0].set_ylabel("power per kz (relative)"); ax[0].set_title(f"{len(kzs)} 2D runs, one per kz", fontsize=9); ax[0].grid(alpha=0.3); ax[0].legend(fontsize=8)
    cum = (np.cumsum(np.where(np.arange(len(kzs)) == 0, 1, 2) * a_kz)) / (np.cumsum(np.where(np.arange(len(kzs)) == 0, 1, 2) * d_kz))
    ax[1].plot(kzs, 100 * cum, "-", color="tab:green"); ax[1].axhline(100 * eff_edge, color="tab:green", ls="--", lw=1)
    ax[1].axhline(100 * eff_kz0, color="tab:orange", ls=":", lw=1.2, label=f"kz = 0 alone (2D line source): {100 * eff_kz0:.1f} %")
    ax[1].set_xlabel("kz included up to"); ax[1].set_ylabel("extraction efficiency [%]"); ax[1].set_title(f"kz integral: {100 * eff_edge:.2f} % into air", fontsize=9); ax[1].grid(alpha=0.3); ax[1].legend(fontsize=8)
    fig.tight_layout(); fig.savefig(os.path.join(OUT, "05_kz.png"), dpi=150); plt.close(fig)

    animate_fields(frames, times, [-(0.5 * CX - PML_C), 0.5 * CX - PML_C, -(0.5 * CY - PML_C), 0.5 * CY - PML_C], os.path.join(OUT, "07_anim_edge.gif"),
                   eps=eps_g, figsize=(5.6, 5.0), dpi=70, clip_percentile=99.0, points=[(SRC_C.x, SRC_C.y, "red", "dipole")],
                   title="edge emitter, kz = 0", legend_loc="lower left")
    with open(os.path.join(OUT, "result.json"), "w") as f_:
        json.dump({"A": {"heights": HEIGHTS.tolist(), "cyl40": effA["cyl40"], "cyl80": effA["cyl80"], "3d40": {str(k): v for k, v in eff3.items()}},
                   "B": {"r": R_SRC, "eff_axis": eff_axis, "m_stop": m_stop, "eff_official": eff_official, "eff_full": eff_full, "rebound": rebound,
                         "m_rebound": m_rebound, "rel": rel.tolist(), "eff_series": eff_series.tolist()},
                   "C": {"n_kz": len(kzs), "kz_max": float(kzs[-1]), "tail": float(d_kz[-1] / dmax), "eff": eff_edge, "eff_kz0": eff_kz0},
                   "wall_s_total": time.time() - t_all, "np": mp.count_processors(), "meep": mp.__version__}, f_, indent=2)
say(f"total {time.time() - t_all:.0f} s on {mp.count_processors()} process(es)")

§4의 발췌 코드와 달리 전체 코드에는 높이 sweep, m 급수와 종료 규칙 비교, kz 적분, GIF, result.json 기록이 들어 있다. MPI로 돌릴 수 있게 collective 호출은 모든 rank에서, 그림 저장은 master에서만 한다. 설계도 두 장은 시간 진행 없이 같은 셀을 만드는 code/extraction_layouts.py로 그렸다. 전체 코드와 helper: https://github.com/jin-castle/meep-examples/blob/main/code.

실행 결과 (2026-10-23 실행, mpirun -np 4):

A (cyl): h 0.1: res40 0.5494, res80 0.5230; h 0.2: res40 0.5214, res80 0.5038; h 0.3: res40 0.4735, res80 0.4645; h 0.4: res40 0.4014, res80 0.4050; h 0.5: res40 0.3018, res80 0.3232; h 0.6: res40 0.1805, res80 0.2213; h 0.7: res40 0.0891, res80 0.1259; h 0.8: res40 0.1095, res80 0.0915; h 0.9: res40 0.2681, res80 0.1745; 253 s
A (3D, res 40): h 0.1: 0.5475 (cyl40 0.5494, cyl80 0.5230); h 0.5: 0.3505 (cyl40 0.3018, cyl80 0.3232); h 0.9: 0.2607 (cyl40 0.2681, cyl80 0.1745); 476 s
B: dipole on the axis (m = 1, r = 0.03): extraction 0.3636
B: r 3.5, m = 0: radiated 8.3457e+03, source 9.8732e+03
B: r 3.5, m = 20: radiated 1.8285e+03, source 5.9457e+03
B: r 3.5, m = 40: radiated 4.1701e+03, source 3.9968e+04
B: r 3.5, m = 60: radiated 2.4012e-04, source 3.0755e-02
B: official stop at m = 32 (radiated/max 5.48e-03) -> efficiency 0.6323; after the stop the series rebounds to 0.382 of the max at m = 41; summed to m = 60: efficiency 0.3616 (last term 2.0e-08); 3502 s
C: 76 kz points up to 1.50 (tail 0.0189); extraction 22.375 % (kz = 0 alone: 32.91 %); 359 s
total 4604 s on 4 process(es)

재현 환경: meep 1.33.0 (MPI) · Python 3.11 · conda install -c conda-forge pymeep=*=mpi_mpich_* · 실행 mpirun -np 4 python extraction_efficiency.py (약 77 min (mpirun -np 4; B alone 58 min))

확인 질문

  1. 11편의 Purcell 인자에서는 $\Delta V$가 필요 없었는데 추출 효율에서는 왜 필요한가.
  2. 축에서 3.5 µm 떨어진 쌍극자의 m 급수가 m 30 근처에서 작아졌다가 다시 커지는 이유를 층에 갇힌 빛과 $m\approx2\pi n r$로 설명해 보라.
  3. 실제 OLED의 발광층에는 위치와 방향이 제각각인 분자가 수천 개 있고, 서로 위상이 맞지 않는다. 이 글처럼 쌍극자 하나씩 돌려 power를 더하면 run이 몇 개 필요한가. 그것을 몇 번의 run으로 줄이는 방법이 있는가. (15편)

9. 더 읽기

]]>jin-castleMeep Example 07 · Metalens의 meta-atom과 phase library — 폭 하나로 위상을 돌리고, 4단계로 빛을 꺾고, 어디서 설계가 틀어지는가2026-10-23T00:00:00+00:002026-10-23T00:00:00+00:00https://jin-castle.github.io/meep-examples/meta-atom English summary
  • What: a silicon bar in a 0.45 µm unit cell is a meta-atom. Sweep its width, record the complex transmission t(w), and you have a phase library. Pick four widths that step the phase by 90°, tile them into a 1.8 µm supercell, and the structure should deflect 1550 nm light to +59.4°.
  • Result: the library covers 1.10 × 2π with |t| between 0.69 and 1.01. The 4-level supercell sends 51 % of the power into the +1 order, 16 % into −1 and 3 % straight through; that is 63 % of the 4-level blazed bound 0.81. A 40-atom array peaks at 58.5°.
  • Takeaway: the library assumes every neighbour is identical. In the real supercell they are not, so the local-phase approximation leaks power into the wrong orders. That gap is what inverse design (post 08) closes.
  • Code: full script at the bottom, ~35 s on one core.

1. 관찰 · 빛의 경로를 먼저 보기

폭이 다른 네 Si 막대를 반복해 배치했습니다. 빛은 아래에서 위로 들어오고, 막대를 지난 파면은 오른쪽으로 기웁니다. 오른쪽으로 나가는 +1차에 모든 빛이 모였는지 왼쪽 차수별 효율 막대그래프로 확인해 보세요.

네 Si 막대 supercell의 차수별 효율과 실제 Re(Ez), 진폭 필드. +1차가 가장 크지만 다른 차수도 남아 있다.
목표 +1차 효율은 약 0.514이고 −1차와 0차에도 빛이 남습니다. 그림의 0.811 점선은 균일 진폭을 가정한 이상적 4단계 위상 모델의 기준입니다.
12개 Si 막대를 지난 펄스의 파면이 오른쪽으로 기울어 전파하는 시간 전개
12-atom 배열에 짧은 펄스(fwidth 0.4 fcen)가 아래에서 올라온다. 막대를 지난 파면이 오른쪽으로 기운 채 나간다. 방향은 위상 기울기가, 폭은 개구가 정한다.

2. 예측 · 결과를 읽기 전에

단위 셀의 위상이 2π 전체를 덮으면, 네 막대를 조합한 배열도 반드시 목표 차수로 100% 보낼까요?

먼저 하나를 골라보세요.
예측의 근거 확인하기

두 번째입니다. 위상을 네 단계로 근사하는 것만으로도 이상적 모델의 효율은 약 0.811입니다. 실제 막대의 진폭은 같지 않고, 단위 셀에서 가정했던 동일한 이웃도 실제 배열에서는 달라집니다. 따라서 2π 커버는 필요한 설계 조건이지 100% 효율 보장이 아닙니다.

3. 원리 이해하기 · 관찰을 설명하는 방법

같은 높이의 Si 막대 폭을 바꿔 목표 상대위상을 선택하고 네 막대를 주기적으로 배열해 위쪽 오른쪽 +1차로 빛을 보내는 개념이다.
Si(n = 3.45) 막대가 SiO₂(n = 1.45) 기판 위에 놓이고 빛은 기판 안에서 +y 방향으로 입사합니다. 막대 높이는 0.9 µm이며 폭 75·100·175·225 nm를 선택해 네 단계의 상대위상을 근사합니다. 네 구간의 주기 1.8 µm를 x 방향으로 반복하며 목표 +1차는 +y 법선에서 오른쪽으로 약 59.4°입니다. 0·90·180·270°는 정확한 측정값이 아닌 목표 상대위상입니다. 입체 음영은 구조 이해를 위한 표현이고, 실제 2D 막대는 z 방향으로 무한합니다.

폭을 위상으로 바꾸는 표가 phase library다

주기 0.45 µm의 단위 셀은 1550 nm에서 0차만 전파합니다. 한 주기 위의 복소 DFT 필드를 평균하고 막대 없는 셀로 나누면 복소 투과계수 t(w)를 얻습니다. 그 크기는 진폭, 위각은 위상입니다. 폭을 바꾸며 두 값을 기록한 표가 library입니다.

\[t(w)=\frac{\langle E_z\rangle(w)}{\langle E_z\rangle(0)}\]

위상은 np.unwrap으로 이어 읽지만, 표본 사이의 실제 변화가 너무 크면 제대로 복원할 수 없습니다. 진폭이 크게 떨어지는 폭도 함께 확인해야 합니다. 여기의 t는 막대 없는 기준 셀 대비 필드 비율이므로 그 크기 자체를 입사 power 대비 효율로 읽지 않습니다.

네 개의 폭으로 기울어진 파면을 만든다

네 구획의 목표 상대위상은 0°, 90°, 180°, 270°입니다. 시작 위상 φ₀를 함께 이동해도 위상 기울기는 같으므로 목표 각도는 유지됩니다. 이 자유도로 진폭이 너무 작은 폭을 피합니다.

\[\Lambda=4\times0.45=1.8\;\mu\mathrm{m},\qquad \sin\theta_{+1}=1.55/1.8\]

목표 각도는 +y 법선에서 오른쪽으로 59.4°입니다. 실제 선택 폭은 75, 100, 175, 225 nm입니다. 각 막대를 고를 때의 library는 같은 폭의 이웃이 무한히 반복되는 조건이며, 서로 다른 폭을 이웃으로 놓는 순간 그 근사가 검증 대상이 됩니다.

기호·설계 가정과 예측표 자세히 보기

주기 Λ_a = 0.45 µm(파장의 0.29배)의 unit cell에 든 Si 막대는 회절하지 않는다. 0차만 전파하므로 unit cell 전체가 복소 투과계수 t(w) 하나로 요약된다. 막대가 넓을수록 유효 굴절률이 커져 위상이 더 쌓인다. 높이 H = 0.9 µm, Δn ≈ 2.45로 어림 Δn·H/λ = 1.4바퀴이니 한 바퀴는 넘길 수 있다.

+1차로 꺾으려면 투과 위상이 x에 비례해 φ(x) = 2πx/Λ여야 한다. Λ = 4Λ_a = 1.8 µm로 두고 네 구획에 0°, 90°, 180°, 270°를 주면 계단식 근사가 된다. N단계로 이산화한 blazed 격자의 +1차 효율 상한은 sinc²(1/N)이고 N = 4면 0.81이다. 그 위에 두 가지 손실이 더 얹힌다. |t|가 균일하지 않은 것, 그리고 library가 “이웃이 모두 나와 같다”는 주기 가정에서 나온 값이라 폭이 다른 이웃 옆에서는 틀린다는 것.

\[t(w)=\frac{\langle E_z\rangle_{\text{period}}(w)}{\langle E_z\rangle_{\text{period}}(0)},\qquad \phi_{\text{target}}(x)=\frac{2\pi x}{\Lambda},\qquad \sin\theta_{+1}=\frac{\lambda}{\Lambda}=\frac{1.55}{1.8}\Rightarrow 59.4^\circ,\qquad \eta_{+1}\le\mathrm{sinc}^2\!\Big(\frac1N\Big)=0.811\]
기호 뜻 코드 변수
Λ_a, Λ atom 주기 0.45, supercell 주기 1.8 µm LA, LAMBDA
w, H 막대 폭(설계 변수), 높이 0.9 µm widths, H
t(w) 빈 셀로 정규화한 0차 복소 투과 t_atom(w) / t_atom(0)
φ₀ 네 목표 위상의 시작점(전역 위상) phi0
w_lib 선택된 네 폭(픽셀 정렬) w_lib
η_m m차 효율 (입사 flux 대비) orders[m]["eff"]
θ_d 설계 편향각 59.44° THETA_D

가정과 유효 범위: 2D, Ez 편광, 수직 입사, 손실 없는 Si(3.45)·SiO₂(1.45). library는 res 40에서 만들고 res 60과 비교한다. far field는 2D 선 초점의 각도 분포다.

결과 보기 전에 맞춰보기

물리량 내 예측 근거    
위상 span (H 0.9, Si) 1바퀴 이상 Δn·H/λ = 1.4의 70~80% (06편 경험)    
위상의 단조성 w에 대해 단조 증가 넓을수록 유효 굴절률 증가    
|t| 넓은 w에서 떨어짐 막대 공명·반사    
+1차 효율 0.81 미만, 0.5~0.7 4단계 상한 × t 불균일 × 이웃 결합
−1차와 0차 0은 아님, 합쳐 0.1~0.2 계단 근사의 누설    
40-atom 빔 방향 59° 근처, 10-atom은 더 벗어남 개구가 짧으면 빔폭이 커지고 피크가 밀린다    

판정 기준: 차수 합이 총 투과 flux와 1%p 이상 다르면 분해 오류. 위상 unwrap에서 인접 차가 π를 넘으면 표본 부족.

4. 직접 실행 · 변수 하나만 바꾸기

한 번만 바꿔보기: 설계 해상도

  1. meta_atom.py와 blogfig.py가 있는 code/ 폴더에서 python meta_atom.py를 실행합니다. 기준 result.json의 선택 폭 네 개와 +1차 효율을 보관합니다.
  2. RES = 40을 RES = 60으로만 바꾸고 다시 실행합니다. 폭 표본 17개 전체와 다른 구조·파라미터는 유지합니다.
  3. 새 library에서 고른 폭과 supercell의 +1차 효율을 원본과 비교합니다. 두 경우 모두 차수 합이 총 투과 flux와 맞는지도 확인합니다.

원본에는 해상도 60의 library 비교가 있지만, 그 library로 다시 설계한 배열의 효율은 기록되어 있지 않습니다. 그 값을 새 실험에서 구합니다. 일부 폭만 재계산하면 unwrap의 branch가 달라질 수 있으므로 표본 전체를 사용합니다.

계산 배치·광원·파라미터 보기
Si 막대 네 개와 SiO2 기판, 광원, mode monitor 및 y 방향 PML 배치
supercell(실험 C). 아래 검은 띠 = SiO₂ 기판(아래 PML 관통), 검은 막대 넷 = 설계된 Si meta-atom, 빨간 가로선 = 기판 안의 평면파 source, 파란 가로선 = 차수를 재는 mode monitor, 녹색 빗금 = y 방향 PML. x는 주기 경계. 보라 × = 종료 감시점. 동그라미 숫자는 §4의 단계 번호다. unit cell(실험 A)은 이 셀의 1/4 폭에 막대 하나다.
파라미터 값 왜 이 값인가 바꾸면
Λ_a 0.45 µm res 40에서 정확히 18 px. 픽셀 정수가 아니면 Meep이 셀을 반올림해 실제 주기와 k_x = m/Λ가 어긋난다 θ_d가 따라 바뀐다
Λ = 4Λ_a, θ_d 1.8 µm, 59.44° θ_d를 먼저 정하지 않고 주기를 픽셀 정수로 고정한 뒤 각도가 따라오게 —
H 0.9 µm 2π를 넘기는 최소 높이 근처 낮추면 span < 2π
widths 0.04–0.42, 17점 unwrap 조건(인접 차 < π)을 만족하는 밀도 성기면 unwrap이 2π 틀린다
RES 40 (수렴성 60) 폭 0.075 µm 막대가 3 px 60에서 위상이 최대 0.82 rad 바뀐다(§5)
종료 monitor 점 Ez 1e-7 감쇠 좁은 대역(fwidth 0.1 fcen) 펄스 꼬리 고정 시간이면 폭마다 다르게 틀린다
far field R = 200 µm, 341각, source는 배열 폭만 배열 옆 빈 구간의 빛이 0° 인공물이 되지 않게 셀 전체 폭 source면 0°가 과대
메타원자 실험의 가우시안 광원 시간 파형과 좁은 대역 스펙트럼
source 파형과 스펙트럼. fwidth 0.1 fcen, width 15.5, t0 = 77.5.

강의 노트북과의 차이: 없다. 파라미터·절차·수치 모두 강의 week 8과 같다(위상 span 1.101 × 2π, 설계 폭 네 개, +1차 0.514). 이 글은 거기에 10_sources의 공식 metasurface_lens 재현에서 얻은 두 가지 주의(wrapped phase를 그대로 불연속으로 읽지 말 것, 목표 위상을 library와 같은 2π branch에 둘 것)를 §4·§6에 덧붙였다.

코드 단계별 설명 보기

읽는 순서: 단위·파라미터 → 재료·구조 → source → Simulation·경계 → monitor → 실행·종료 → 후처리. 전파 방향이 +y라서 06편과 x·y가 바뀐다. 실험 A(library)는 unit cell, C(supercell)는 네 배 넓은 셀, D(far field)는 PML 전면의 유한 셀이다.

① 단위와 파라미터 — 어떤 숫자를 고정하는가

wl = 1.55; fcen = 1 / wl; fwidth = 0.1 * fcen
Si, SiO2 = mp.Medium(index=3.45), mp.Medium(index=1.45)
N_SEC = 4                       # phase levels per supercell period
LA = 0.45                       # atom period [um]: 18 px at resolution 40
LAMBDA = N_SEC * LA             # supercell period 1.80 um
THETA_D = np.degrees(np.arcsin(wl / LAMBDA))   # 59.44 deg
H = 0.9                         # bar height [um]
RES = 40
DPML, DSUB, DAIR = 1.0, 1.0, 1.0
SY = DPML + DSUB + H + DAIR + DPML
Y_BOT = -0.5 * SY; Y_DEV = Y_BOT + DPML + DSUB; SRC_Y = Y_BOT + DPML + 0.3; MON_Y = -Y_BOT - DPML - 0.3
BLAZED_BOUND = (np.sin(np.pi / N_SEC) / (np.pi / N_SEC)) ** 2   # 0.8106
  • 무엇: atom 주기를 픽셀 정수로 먼저 고정하고, supercell 주기와 편향각을 거기서 유도한다. blazed 상한도 여기서 계산해 둔다.
  • 왜: θ_d = 60°로 잡으면 Λ = 1.7898 µm로 픽셀 정수가 아니다. Meep이 셀을 반올림하면 “주기”와 차수 계산 k_x = m/Λ가 어긋난다. 숫자를 먼저 고정하고 각도가 따라오게 하면 이 문제가 없다.
  • 틀리면: 셀 반올림 경고가 뜨고 ±1차의 각도·효율이 미세하게 틀린다. 06편에서 1.2 µm 주기가 res 22에서 반올림된 것도 같은 문제였다.

② 재료와 구조 — 무엇이 어디에 있는가

def geometry_bars(widths, period):
    g = [mp.Block(center=mp.Vector3(0, Y_BOT + 0.5 * (DPML + DSUB)), size=mp.Vector3(mp.inf, DPML + DSUB), material=SiO2)]
    n = len(widths)
    for j, w in enumerate(widths):
        if w > 0:
            xj = -0.5 * period + (j + 0.5) * period / n
            g.append(mp.Block(center=mp.Vector3(xj, Y_DEV + 0.5 * H), size=mp.Vector3(w, H), material=Si))
    return g
  • 무엇: 기판 위에 구획마다 Si 막대 하나. widths=[w]면 unit cell, widths=w_lib면 4구획 supercell이다.
  • 왜: library와 supercell이 같은 함수로 만들어져야 “library 값을 그대로 썼는데 왜 다른가”를 물을 수 있다. w = 0은 막대 없는 reference다.
  • 틀리면: 막대 중심을 구획 중심에 두지 않으면 위상 기울기에 오프셋이 생겨 0차가 커진다.

③ Source — 빛을 어떻게 넣는가

def plane_wave(period, fw=fwidth, integrated=False):
    return [mp.Source(mp.GaussianSource(fcen, fwidth=fw, is_integrated=integrated), component=mp.Ez,
                      center=mp.Vector3(0, SRC_Y), size=mp.Vector3(period, 0))]
  • 무엇: 기판 안에서 셀 폭 전체의 가로선. +y로 가는 평면파.
  • 왜: 주기 셀에서는 셀 폭 = 주기라 그 자체로 평면파다. 유한 배열(D)에서만 is_integrated=True와 “배열 폭만큼”의 선원을 쓴다.
  • 틀리면: 유한 배열에서 셀 전체 폭으로 쏘면 배열 옆 빈 기판을 그대로 통과한 빛이 0° 피크로 크게 섞인다.

④ Simulation과 경계 — 계산 상자와 PML

def periodic_sim(widths, period, resolution=RES):
    return mp.Simulation(resolution=resolution, cell_size=mp.Vector3(period, SY), geometry=geometry_bars(widths, period),
                         boundary_layers=[mp.PML(thickness=DPML, direction=mp.Y)], k_point=mp.Vector3(),
                         sources=plane_wave(period))
  • 무엇: PML은 y에만, x는 k_point=0의 주기 경계. 06편과 축만 다르다.
  • 왜: unit cell의 t(w)는 “무한 주기 배열 안의 막대”의 값이다. 이 가정이 뒤에서 깨지는 지점을 보게 된다.
  • 틀리면: unit cell에 PML을 x에도 두면 고립된 막대 하나의 산란을 계산하게 되고 t(w)의 의미가 달라진다.

⑤ Monitor — 무엇을 재는가

# A. unit cell: DFT of Ez on a line across one period; its mean is the zeroth Fourier coefficient
dft = sim.add_dft_fields([mp.Ez], fcen, 0, 1, center=mp.Vector3(0, MON_Y), size=mp.Vector3(LA, 0))
t = np.mean(sim.get_dft_array(dft, mp.Ez, 0))
# C. supercell: a mode monitor across the period, decomposed order by order
mon = sim.add_mode_monitor(fcen, 0, 1, mp.ModeRegion(center=mp.Vector3(0, MON_Y), size=mp.Vector3(LAMBDA, 0)))
a_m = sim.get_eigenmode_coefficients(mon, mp.DiffractedPlanewave((m, 0, 0), mp.Vector3(1, 0, 0), 1, 0)).alpha[0, 0, 0]
  • 무엇: unit cell에서는 한 주기 위의 복소 DFT를 평균해 t를 얻고, supercell에서는 06편처럼 차수별 진폭을 얻는다.
  • 왜: 주기 함수의 한 주기 평균은 0차 Fourier 계수다. subwavelength 셀에서는 0차만 전파하므로 평균 하나가 투과 전부다. get_array가 아니라 get_dft_array인 이유는 마지막 시각의 snapshot이 아니라 정상상태 복소 진폭이 필요하기 때문이다.
  • 틀리면: get_array로 재면 펄스가 지나간 뒤의 잔재를 평균하게 된다. monitor를 막대 바로 위에 두면 소멸파가 섞인다(여기서는 0.7 µm 위).

⑥ 실행과 종료 조건 — 언제 멈추는가

sim.run(until_after_sources=mp.stop_when_fields_decayed(10, mp.Ez, mp.Vector3(0, MON_Y), 1e-7))
  • 무엇: monitor 점의 Ez가 10⁻⁷로 줄 때까지. 34번의 library run 모두 같은 조건.
  • 왜: 복소 위상은 진폭보다 꼬리에 민감하다. 임계값을 보통(10⁻⁶)보다 낮게 둔다.
  • 틀리면: 폭마다 종료 시각이 달라져도 상관없지만, 고정 시간으로 끊으면 어떤 폭에서는 꼬리가 남아 위상이 틀어진다.

⑦ 후처리 — 숫자로 바꾸기

t_ref = t_atom(0.0)
t = np.array([t_atom(w) / t_ref for w in widths])
phase = np.unwrap(np.angle(t)); phase -= phase[0]          # library: |t|, relative phase

# design: for each trial phi0, four targets phi0 + k*pi/2 -> widths by inverse interpolation; keep the phi0 with the largest min|t|
targets = phi0 + np.arange(N_SEC) * (2 * np.pi / N_SEC)
ws = np.interp(targets, ph_dense, w_dense)
w_lib = np.round(ws * RES) / RES                            # snap to the pixel grid

eff_m = abs(a_m) ** 2 / P_in                               # supercell: efficiency per order, P_in from an all-SiO2 run
  • 무엇: 빈 셀로 나눈 t의 위상을 unwrap해 library를 만들고, 목표 위상에서 폭을 역으로 읽으며, 전역 위상 φ₀를 골라 min|t|를 키운다. 폭은 픽셀에 맞춘다.
  • 왜: np.angle은 (−π, π]의 wrapped 값이다. 10_sources의 phase map 노트가 경고하듯, 거기서 보이는 급변은 물리적 불연속이 아니라 branch cut일 수 있다. unwrap은 인접 표본의 차가 π보다 작을 때만 옳으므로 폭을 촘촘히 잡았다. library의 위상은 상대값이라 상수를 더해도 되고, 그 자유도가 |t| 균일성을 사는 데 쓰인다.
  • 틀리면: 목표 위상을 library와 다른 2π branch에 두고 clip하면 네 폭이 모두 library 최솟값으로 몰린다(10_sources 실패 사례). 픽셀 정렬을 빼면 supercell 막대 폭이 library와 다른 값으로 반올림된다.

함정: 성긴 폭 부분집합만 다시 돌려 수렴성을 보면 unwrap이 어긋나 2π만큼 틀린다. 수렴성 비교는 같은 폭 격자 전체로 library를 다시 만든 뒤 한다(§5).

5. 해석 · 측정값과 한계를 함께 읽기

위상 한 바퀴와 효율 100%는 다르다

원본 library는 위상 1.101 × 2π를 덮고, 진폭 범위는 0.689–1.011입니다. 선택 폭의 진폭은 1.001, 0.959, 0.885, 0.885로 균일하지 않습니다.

실제 supercell의 차수 각도 입사 flux 대비 효율
−1 −59.4° 0.1576
0 0° 0.0325
+1 +59.4° 0.5144

합 0.7045는 전체 투과 flux와 일치합니다. 목표 차수의 0.5144는 이상적 4단계 모델 0.8106의 63.5%입니다. 이 차이를 진폭 불균일과 이웃 결합으로 각각 얼마씩 나눌지는 이 실험만으로 알 수 없습니다.

유한 배열에서는 개구도 중요합니다. 10개 막대(4.5 µm)의 피크는 49.5°, 40개(18 µm)는 58.5°입니다. 넓은 배열의 빔이 더 좁아지면서 목표 59.4°에 가까워집니다.

막대 폭에 따른 투과 진폭, 상대 위상 및 해상도 40과 60의 위상 차
왼쪽 |t|, 가운데 위상(w = 0.04 기준, 2π 단위), 오른쪽 해상도 40 → 60의 위상 차. 위상은 단조 증가하며 1.10바퀴를 돈다. |t|는 w ≈ 0.13과 0.3 근처에서 0.7까지 떨어진다. 해상도 차는 w = 0.087에서 0.49 rad, 0.42에서 0.39 rad로, 설계 간격 π/2의 10%(초록 띠)를 여러 점에서 넘는다.
네 목표 위상에서 선택한 막대 폭, 각 폭의 투과 진폭과 supercell 구조
왼쪽: 네 목표 위상(φ₀ + 0°, 90°, 180°, 270°)에서 읽은 폭. 가운데: 그 폭의 |t|. 오른쪽: 만들어지는 supercell 한 주기.
10개와 40개 막대 배열의 원거리 각도 분포와 설계각 59.4도 비교
library 폭을 반복한 10-atom(4.5 µm)과 40-atom(18 µm) 배열의 far field. 회색 점선이 설계각 59.4°.
전체 측정표·예측 비교·수렴성 기록 보기

A. Phase library

양 res 40 res 60
위상 span / 2π 1.101 1.163
|t| 범위 0.689–1.011 0.690–1.015
max |Δφ| (60 − 40) — 0.82 rad (2π의 13%)

B. 4단계 설계

구획 목표 위상 w (µm, 픽셀 정렬) |t|
0 0.797 rad 0.075 1.001
1 2.368 0.100 0.959
2 3.938 0.175 0.885
3 5.509 0.225 0.885

φ₀ = 0.797 rad가 min|t| = 0.885를 준다. 네 폭 중 셋이 0.1 µm 아래이거나 근처라 res 40에서 3~4 px다.

C. Supercell: 빛은 어디로 가는가

차수 각도 효율
−1 −59.4° 0.158
0 0° 0.033
+1 +59.4° 0.514
합   0.705 = 총 투과 flux 0.705

+1차 0.514는 상한 0.811의 63.5%다. 나머지는 −1차(0.158)와 0차(0.033), 그리고 반사(1 − 0.705 = 0.295)로 갔다.

D. 유한 배열의 far field

배열 개구 주 lobe 어림 빔폭 λ/(D cos θ)
10 atom 4.5 µm +49.5° 38.8°
40 atom 18 µm +58.5° 9.7°

예측과 비교

물리량 내 예측 (§2) 시뮬레이션 판정
위상 span 1바퀴 이상 1.10 × 2π ✅
단조성 단조 증가 17점 모두 증가 ✅
|t| 넓은 w에서 하락 0.13·0.30 근처 0.69~0.71 ✅
+1차 효율 0.5~0.7 0.514 ✅
−1 + 0차 0.1~0.2 0.191 ✅
빔 방향 40 atom ≈ 59°, 10 atom은 벗어남 58.5°, 49.5° ✅

예측은 맞았지만 상한 대비 63.5%의 손실을 어디에 돌릴지는 숫자가 말해 준다. |t|의 불균일은 0.885² ≈ 0.78 정도의 몫이다. 그 밖의 손실이 “이웃이 같다”는 주기 가정에서 온다. library의 각 폭은 좌우에 같은 폭의 막대가 있을 때의 값인데, supercell에서는 0.075 옆에 0.100, 0.175 옆에 0.225가 있다. 폭이 가장 급히 바뀌는 구획 3 → 0 경계(0.225 → 0.075)에서 위상 오차가 가장 크다. 08편의 inverse design은 이 간극을 네 폭이 아니라 픽셀 단위 자유도로 메운다.

수렴성

양 res 40 res 60 비고
위상 span / 2π 1.101 1.163 6%
max |Δφ| — 0.82 rad w = 0.087, 0.42에서 최대
max Δ|t| — 0.071  

위상이 해상도에 13%(2π 기준)까지 움직인다. 설계 간격 π/2의 절반이다. 가장 좁은 막대(3 px)가 원인이고, 설계에 쓸 폭 구간의 오차를 따로 봐야 한다. 이 글의 supercell 수치(0.514)는 res 40 library로 설계하고 res 40으로 검증한 값이라 자기일관적이지만, res 60으로 다시 설계하면 폭과 효율이 달라질 것이다.

주장할 수 있는 것 / 없는 것

  • 할 수 있는 것: Si 막대(H 0.9, 주기 0.45)의 library는 1550 nm에서 2π를 덮는다. 4단계 설계 supercell은 +1차에 51%를 보내고, 유한 배열은 설계각 근처로 빔을 만든다. 차수 합과 총 flux가 일치해 분해는 옳다.
  • 할 수 없는 것: 효율 0.514의 둘째 자리. res 60으로 library를 다시 만들면 폭이 바뀐다. 3D·편광·파장 의존성. “국소 위상 근사 때문”이라는 손실 배분의 정량적 분해(두 손실을 따로 끄는 실험은 하지 않았다).
증상별 점검표 보기
증상 원인 고치는 법
위상 곡선에 2π 점프 unwrap 실패(표본 성김) 또는 부분집합 재계산 폭 간격을 줄이고 전체 격자로 다시 만들기
네 폭이 모두 같은 값으로 몰림 목표 위상이 library와 다른 2π branch에서 clip target_on_map = (target − φ_min) mod 2π + φ_min
셀 반올림 경고, 각도가 미세하게 틀림 주기가 픽셀 정수가 아님 주기를 먼저 픽셀 정수로, 각도는 따라오게
far field 0°에 큰 피크 유한 배열 source가 셀 전체 폭 배열 폭만큼만, is_integrated=True
차수 합 ≠ 총 flux 소멸 차수 포함 또는 monitor가 막대에 근접 |k_x| < k₀인 차수만, monitor를 띄우기
t(w)가 실행마다 다름 get_array snapshot 사용 add_dft_fields + get_dft_array

6. 확인 · 두 질문에 답해보기

1. 전역 위상 φ₀를 바꾸면 폭 네 개가 달라져도 목표 각도는 왜 같을까요?

설명 확인하기

모든 목표 위상에 같은 상수를 더해도 위치에 따른 위상 기울기는 같습니다. 방향은 기울기가 정합니다. 다만 선택 폭과 진폭, 실제 이웃 결합이 달라져 실제 효율은 달라질 수 있습니다.

2. library의 2π 커버와 차수 합 = flux가 모두 맞으면 소자 설계가 끝난 것일까요?

설명 확인하기

아닙니다. 전자는 목표 위상을 고를 수 있는지, 후자는 차수 분해가 전체 투과와 맞는지를 확인합니다. 실제 목표 차수 효율, 해상도 수렴성, 유한 개구와 적용할 3D 조건은 별도로 검증해야 합니다.

7. 참고 · 전체 코드와 원본 기록

아래 전체 프로그램은 원본 그대로입니다. 실행 환경과 결과 기록을 함께 확인하세요.

meta_atom.py (클릭해서 펼치기) 
"""Meep Example 07 - Meta-atoms and a phase library.

Local view of a periodic structure: each Si bar (width w, height H) in a subwavelength unit cell
transmits a plane wave with its own complex coefficient t(w). Collect t(w) -> phase library, pick
4 widths that step the phase by 90 deg, tile them into a supercell that should deflect light to +1,
and check how far the real device falls short of the 4-level blazed bound. Then a finite array and
its far field, and a GIF of the tilted wavefront.

  A. phase library: |t(w)|, arg t(w) at resolution 40 and 60 (reference = empty unit cell)
  B. 4-level design: phase targets phi0 + k*pi/2 -> widths; phi0 chosen to maximise min |t|
  C. supercell (period 4*La): orders by DiffractedPlanewave, sum = total flux, vs sinc^2(1/4) = 0.8106
  D. finite arrays (10 and 40 atoms): near2far pattern, main lobe vs the design angle
  E. GIF: 12-atom array, the wavefront leaves tilted

Run:  python meta_atom.py             (~4 min on one core)
Out:  00_source.png, 01_layout.png, 02_library.png, 03_design.png, 04_supercell.png,
      05_farfield.png, 06_anim_array.gif, result.json   (-> ../assets/07/)
"""
import json
import os
import sys
import time

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import meep as mp

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from blogfig import Label, animate_fields, annotated_layout, record_frames, source_figure   # noqa: E402

OUT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "assets", "07")
os.makedirs(OUT, exist_ok=True)
t_all = time.time()

# ---------------------------------------------------------------- (1) units & parameters
wl = 1.55
fcen = 1 / wl
fwidth = 0.1 * fcen
Si = mp.Medium(index=3.45)
SiO2 = mp.Medium(index=1.45)
N_SEC = 4                       # phase levels per supercell period
LA = 0.45                       # atom period [um]: 18 px at resolution 40 (integer pixels matter: see post)
LAMBDA = N_SEC * LA             # supercell period 1.80 um
THETA_D = float(np.degrees(np.arcsin(wl / LAMBDA)))   # +1 order angle: 59.44 deg
H = 0.9                         # bar height [um]
RES = 40
DPML, DSUB, DAIR = 1.0, 1.0, 1.0
SY = DPML + DSUB + H + DAIR + DPML
Y_BOT = -0.5 * SY
Y_DEV = Y_BOT + DPML + DSUB     # substrate top = bar bottom
SRC_Y = Y_BOT + DPML + 0.3      # source inside the substrate
MON_Y = -Y_BOT - DPML - 0.3     # monitor in the air above the bars
BLAZED_BOUND = (np.sin(np.pi / N_SEC) / (np.pi / N_SEC)) ** 2   # 4-level phase quantisation limit


# ---------------------------------------------------------------- (2) geometry: substrate + Si bars
def geometry_bars(widths, period):
    """SiO2 substrate through the bottom PML plus one Si bar per section (bar j centred in section j)."""
    g = [mp.Block(center=mp.Vector3(0, Y_BOT + 0.5 * (DPML + DSUB)), size=mp.Vector3(mp.inf, DPML + DSUB), material=SiO2)]
    n = len(widths)
    for j, w in enumerate(widths):
        if w > 0:
            xj = -0.5 * period + (j + 0.5) * period / n
            g.append(mp.Block(center=mp.Vector3(xj, Y_DEV + 0.5 * H), size=mp.Vector3(w, H), material=Si))
    return g


# ---------------------------------------------------------------- (3) source: plane wave in the substrate, travelling +y
def plane_wave(period, fw=fwidth, integrated=False):
    return [mp.Source(mp.GaussianSource(fcen, fwidth=fw, is_integrated=integrated), component=mp.Ez,
                      center=mp.Vector3(0, SRC_Y), size=mp.Vector3(period, 0))]


# ---------------------------------------------------------------- (4) periodic cell: PML in y only, Bloch-periodic in x (k = 0)
def periodic_sim(widths, period, resolution=RES):
    return mp.Simulation(resolution=resolution, cell_size=mp.Vector3(period, SY), geometry=geometry_bars(widths, period),
                         boundary_layers=[mp.PML(thickness=DPML, direction=mp.Y)], k_point=mp.Vector3(),
                         sources=plane_wave(period))


# ================================================================ A. phase library
def t_atom(w, resolution=RES):
    """Zeroth-order complex transmission of one unit cell: the DFT of Ez on the monitor line averaged
    over one period (the average over a period IS the zeroth Fourier coefficient). w = 0 -> reference."""
    sim = periodic_sim([w], LA, resolution)
    dft = sim.add_dft_fields([mp.Ez], fcen, 0, 1, center=mp.Vector3(0, MON_Y), size=mp.Vector3(LA, 0))   # (5)
    sim.run(until_after_sources=mp.stop_when_fields_decayed(10, mp.Ez, mp.Vector3(0, MON_Y), 1e-7))      # (6)
    t = complex(np.mean(sim.get_dft_array(dft, mp.Ez, 0)))                                                 # (7)
    sim.reset_meep()
    return t


def build_library(widths, resolution=RES):
    t_ref = t_atom(0.0, resolution)
    t = np.array([t_atom(w, resolution) / t_ref for w in widths])
    phase = np.unwrap(np.angle(t))
    return np.abs(t), phase - phase[0]


source_figure(fcen, fwidth, os.path.join(OUT, "00_source.png"), wl_scale=1000.0, wl_unit="nm", time_unit="um/c")
widths = np.linspace(0.04, 0.42, 17)
amp40, ph40 = build_library(widths, RES)
amp60, ph60 = build_library(widths, 60)
span40 = float(ph40.max() - ph40.min())
dphi = ph60 - ph40
print(f"A. library H={H}: phase span = {span40:.3f} rad = {span40 / (2*np.pi):.3f} x 2pi; |t| in [{amp40.min():.3f}, {amp40.max():.3f}]; "
      f"monotonic: {bool(np.all(np.diff(ph40) > 0))}; res 60 vs 40: max|dphi| = {np.max(np.abs(dphi)):.3f} rad, max d|t| = {np.max(np.abs(amp60 - amp40)):.3f}")

fig, ax = plt.subplots(1, 3, figsize=(14, 3.8))
ax[0].plot(widths, amp40, "o-", label="resolution 40"); ax[0].plot(widths, amp60, "s--", label="resolution 60")
ax[0].set_ylim(0, 1.15); ax[0].set_xlabel("bar width w [um]"); ax[0].set_ylabel("|t|"); ax[0].set_title("transmission amplitude", fontsize=9); ax[0].grid(alpha=0.3); ax[0].legend(fontsize=8)
ax[1].plot(widths, ph40 / (2 * np.pi), "o-", label="resolution 40"); ax[1].plot(widths, ph60 / (2 * np.pi), "s--", label="resolution 60")
ax[1].axhline(1.0, ls="--", color="crimson", lw=1); ax[1].text(0.05, 1.02, "2 pi", color="crimson", fontsize=8)
ax[1].set_xlabel("bar width w [um]"); ax[1].set_ylabel("phase / 2 pi  (relative to w = 0.04)"); ax[1].set_title(f"transmission phase: span {span40/(2*np.pi):.2f} x 2pi", fontsize=9); ax[1].grid(alpha=0.3); ax[1].legend(fontsize=8)
ax[2].plot(widths, dphi, "o-", color="tab:red"); ax[2].axhline(0, color="k", lw=0.8)
ax[2].axhspan(-0.1 * 2 * np.pi / N_SEC, 0.1 * 2 * np.pi / N_SEC, color="tab:green", alpha=0.15)
ax[2].set_xlabel("bar width w [um]"); ax[2].set_ylabel("phase(60) - phase(40) [rad]"); ax[2].set_title("resolution error; green = 10 % of the pi/2 design step", fontsize=9); ax[2].grid(alpha=0.3)
fig.suptitle(f"meta-atom phase library: Si bar, H = {H} um, period {LA} um, lambda = 1550 nm", fontsize=10)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "02_library.png"), dpi=150); plt.close(fig)

# ================================================================ B. 4-level design from the library
w_dense = np.linspace(widths[0], widths[-1], 2001)
ph_dense = np.interp(w_dense, widths, ph40)
amp_dense = np.interp(w_dense, widths, amp40)
best = None
for phi0 in np.linspace(0.0, span40 - 1.5 * np.pi, 400):
    targets = phi0 + np.arange(N_SEC) * (2 * np.pi / N_SEC)
    if targets.max() > span40:
        continue
    ws = np.interp(targets, ph_dense, w_dense)           # phase -> width (library is monotonic)
    amps = np.interp(ws, w_dense, amp_dense)
    if best is None or amps.min() > best[0]:
        best = (float(amps.min()), float(phi0), ws, amps, targets)
min_amp, phi0, w_sel, a_sel, targets = best
w_lib = np.round(w_sel * RES) / RES                       # snap to the pixel grid
print(f"B. design: phi0 = {phi0:.3f} rad, widths = {np.round(w_lib, 3).tolist()} um, |t| = {np.round(a_sel, 3).tolist()}, min |t| = {min_amp:.3f}")

fig, ax = plt.subplots(1, 3, figsize=(14, 3.8))
ax[0].plot(w_dense, ph_dense, color="tab:blue")
for j in range(N_SEC):
    ax[0].axhline(targets[j], color="gray", ls=":", lw=0.8); ax[0].plot([w_sel[j]], [targets[j]], "o", color="crimson")
    ax[0].annotate(f"section {j}: {np.degrees(targets[j] - targets[0]):.0f} deg", (w_sel[j], targets[j]), textcoords="offset points", xytext=(6, -11), fontsize=8)
ax[0].set_xlabel("bar width w [um]"); ax[0].set_ylabel("phase [rad]"); ax[0].set_title("solve phase -> width for 4 targets", fontsize=9); ax[0].grid(alpha=0.3)
ax[1].plot(w_dense, amp_dense, color="tab:blue"); ax[1].plot(w_sel, a_sel, "o", color="crimson")
ax[1].axhline(min_amp, ls="--", color="crimson", lw=1, label=f"min |t| = {min_amp:.3f}"); ax[1].set_ylim(0, 1.15)
ax[1].set_xlabel("bar width w [um]"); ax[1].set_ylabel("|t|"); ax[1].set_title("the price: |t| is not uniform", fontsize=9); ax[1].grid(alpha=0.3); ax[1].legend(fontsize=8)
for j in range(N_SEC):
    xj = -0.5 * LAMBDA + (j + 0.5) * LA
    ax[2].add_patch(plt.Rectangle((xj - 0.5 * LA, 0), LA, H, facecolor="none", edgecolor="gray", ls=":"))
    ax[2].add_patch(plt.Rectangle((xj - 0.5 * w_lib[j], 0), w_lib[j], H, facecolor="tab:blue", alpha=0.75))
    ax[2].text(xj, H * 1.08, f"{np.degrees(targets[j] - targets[0]):.0f} deg\nw = {w_lib[j]:.3f}", ha="center", fontsize=7.5)
ax[2].axhline(0, color="k", lw=1.2); ax[2].set_xlim(-0.55 * LAMBDA, 0.55 * LAMBDA); ax[2].set_ylim(-0.1 * H, 1.5 * H); ax[2].set_aspect("equal")
ax[2].set_xlabel("x [um]"); ax[2].set_ylabel("y [um]"); ax[2].set_title("one supercell period (1.8 um)", fontsize=9)
fig.suptitle("4-level phase design: four widths that step the phase by 90 deg", fontsize=10)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "03_design.png"), dpi=150); plt.close(fig)

# ================================================================ C. supercell: where does the light go?
stop_sc = mp.stop_when_fields_decayed(10, mp.Ez, mp.Vector3(0, MON_Y), 1e-7)
mon_region = mp.ModeRegion(center=mp.Vector3(0, MON_Y), size=mp.Vector3(LAMBDA, 0))
sim = mp.Simulation(resolution=RES, cell_size=mp.Vector3(LAMBDA, SY), default_material=SiO2,     # reference: all substrate
                    boundary_layers=[mp.PML(thickness=DPML, direction=mp.Y)], k_point=mp.Vector3(), sources=plane_wave(LAMBDA))
fl = sim.add_mode_monitor(fcen, 0, 1, mon_region)
sim.run(until_after_sources=stop_sc)
P_in = float(mp.get_fluxes(fl)[0])
sim.reset_meep()

sim = periodic_sim(w_lib, LAMBDA)
mon = sim.add_mode_monitor(fcen, 0, 1, mon_region)
annotated_layout(
    sim, os.path.join(OUT, "01_layout.png"), dpml=DPML, figsize=(5.2, 7.0), axis_step=0.5,
    title=f"supercell: 4 Si bars on SiO2, period {LAMBDA} um, periodic in x, PML in y",
    params_text=f"wl={wl} res={RES}\nLa={LA} H={H}\nw={np.round(w_lib,3).tolist()}",
    params_xy=(-0.85, 2.35), pml_xy=(-0.5, Y_BOT + 0.5 * DPML), decay_point=(0, MON_Y), decay_text_xy=(-0.1, 1.75),
    labels=[Label("4 Si bars (geometry)", (-0.5 * LAMBDA + 0.5 * LA, Y_DEV + 0.5 * H), (-0.85, 1.25), step=2, color="black"),
            Label("plane wave in SiO2", (0.3, SRC_Y), (-0.85, SRC_Y - 0.35), step=3, color="red"),
            Label("mode monitor: orders", (0.5, MON_Y), (-0.85, MON_Y + 0.35), step=5, color="blue")])
dft_sc = sim.add_dft_fields([mp.Ez], fcen, 0, 1, center=mp.Vector3(), size=mp.Vector3(LAMBDA, SY))
sim.run(until_after_sources=stop_sc)
T_total = float(mp.get_fluxes(mon)[0] / P_in)
field_sc = sim.get_dft_array(dft_sc, mp.Ez, 0)
eps_sc = sim.get_epsilon()
orders = {}
for m in range(-3, 4):
    kx = m / LAMBDA
    if abs(kx) >= fcen:
        continue                                                                    # evanescent
    a = sim.get_eigenmode_coefficients(mon, mp.DiffractedPlanewave((m, 0, 0), mp.Vector3(1, 0, 0), 1, 0)).alpha[0, 0, 0]
    orders[m] = {"angle_deg": float(np.degrees(np.arcsin(kx / fcen))), "eff": float(abs(a) ** 2 / P_in)}
sim.reset_meep()
sum_orders = sum(v["eff"] for v in orders.values())
print("C. supercell orders: " + ", ".join(f"m={m}: {v['eff']:.4f} ({v['angle_deg']:+.1f} deg)" for m, v in sorted(orders.items())) +
      f"; sum = {sum_orders:.4f}, T_total = {T_total:.4f}; +1 efficiency {orders[1]['eff']:.4f} = {orders[1]['eff'] / BLAZED_BOUND * 100:.1f} % of the 4-level bound {BLAZED_BOUND:.4f}")

ext_sc = [-0.5 * LAMBDA, 0.5 * LAMBDA, Y_BOT, -Y_BOT]
fig, ax = plt.subplots(1, 3, figsize=(13, 4.6), gridspec_kw={"width_ratios": [1.4, 1, 1]})
ms = sorted(orders)
bars = ax[0].bar([f"m = {m}\n{orders[m]['angle_deg']:+.0f} deg" for m in ms], [orders[m]["eff"] for m in ms], color=["tab:blue" if m == 1 else "tab:gray" for m in ms])
ax[0].axhline(BLAZED_BOUND, ls="--", color="crimson", lw=1.2, label=f"4-level blazed bound {BLAZED_BOUND:.3f}")
for b, m in zip(bars, ms):
    ax[0].text(b.get_x() + b.get_width() / 2, orders[m]["eff"] + 0.01, f"{orders[m]['eff']:.3f}", ha="center", fontsize=8)
ax[0].set_ylim(0, 1.0); ax[0].set_ylabel("efficiency (fraction of incident power)"); ax[0].set_title(f"orders: sum {sum_orders:.3f} = total flux {T_total:.3f}", fontsize=9); ax[0].grid(axis="y", alpha=0.3); ax[0].legend(fontsize=8)
xs = np.linspace(ext_sc[0], ext_sc[1], eps_sc.shape[0]); ys = np.linspace(ext_sc[2], ext_sc[3], eps_sc.shape[1])
lim = float(np.max(np.abs(np.real(field_sc))))
ax[1].imshow(np.real(field_sc).T, extent=ext_sc, origin="lower", cmap="RdBu", vmin=-lim, vmax=lim, aspect="equal"); ax[1].set_title("Re(Ez): the wavefront tilts", fontsize=9)
ax[2].imshow(np.abs(field_sc).T, extent=ext_sc, origin="lower", cmap="inferno", aspect="equal"); ax[2].set_title("|Ez|", fontsize=9)
for a in ax[1:]:
    a.contour(xs, ys, eps_sc.T, levels=[1.5, 6.0], colors="w", linewidths=0.6)
    a.axhline(MON_Y, color="lime", lw=0.8, ls="--"); a.set_xlabel("x [um]")
ax[1].set_ylabel("y [um]")
fig.suptitle(f"library supercell, design angle {THETA_D:.1f} deg", fontsize=10)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "04_supercell.png"), dpi=150); plt.close(fig)


# ================================================================ D. finite arrays: far field
def finite_array(n_atom, resolution=30, pad=1.0, R_ff=200.0, angles=np.linspace(-85, 85, 341)):
    aperture = n_atom * LA
    sx = aperture + 2 * pad + 2 * DPML
    n2f_y = Y_DEV + H + 0.5 * DAIR
    geom = [mp.Block(center=mp.Vector3(0, Y_BOT + 0.5 * (DPML + DSUB)), size=mp.Vector3(mp.inf, DPML + DSUB), material=SiO2)]
    for j in range(n_atom):
        xj = -0.5 * aperture + (j + 0.5) * LA
        geom.append(mp.Block(center=mp.Vector3(xj, Y_DEV + 0.5 * H), size=mp.Vector3(w_lib[j % N_SEC], H), material=Si))
    sim = mp.Simulation(resolution=resolution, cell_size=mp.Vector3(sx, SY), boundary_layers=[mp.PML(DPML)], geometry=geom,
                        sources=[mp.Source(mp.GaussianSource(fcen, fwidth=fwidth, is_integrated=True), component=mp.Ez,
                                           center=mp.Vector3(0, SRC_Y), size=mp.Vector3(aperture, 0))])   # source only under the array
    n2f = sim.add_near2far(fcen, 0, 1, mp.Near2FarRegion(center=mp.Vector3(0, n2f_y), size=mp.Vector3(sx - 2 * DPML, 0)))
    sim.run(until_after_sources=mp.stop_when_fields_decayed(30, mp.Ez, mp.Vector3(0, n2f_y), 1e-6))
    I = np.array([abs(sim.get_farfield(n2f, mp.Vector3(R_ff * np.sin(np.radians(a)), R_ff * np.cos(np.radians(a))))[2]) ** 2 for a in angles])
    sim.reset_meep()
    return aperture, angles, I / I.max()


ff = {}
fig, ax = plt.subplots(figsize=(8, 4.2))
for n_atom, color in ((10, "tab:orange"), (40, "tab:blue")):
    aperture, angles, pattern = finite_array(n_atom)
    peak = float(angles[np.argmax(pattern)])
    bw = float(np.degrees(wl / (aperture * np.cos(np.radians(THETA_D)))))
    ff[n_atom] = {"aperture_um": aperture, "peak_deg": peak, "beamwidth_est_deg": bw}
    ax.plot(angles, pattern, color=color, label=f"{n_atom} atoms (D = {aperture:.1f} um): peak {peak:+.1f} deg, est. width {bw:.1f} deg")
    print(f"D. {n_atom} atoms: aperture {aperture:.2f} um, main lobe {peak:+.1f} deg (design {THETA_D:+.2f}), est. beam width {bw:.1f} deg")
ax.axvline(THETA_D, ls="--", color="gray", lw=1); ax.text(THETA_D, 1.03, f" design {THETA_D:.1f} deg", color="gray", fontsize=8)
ax.set_xlabel("angle from the normal [deg]"); ax.set_ylabel("normalized |Ez|^2 (far field)"); ax.set_ylim(0, 1.12); ax.grid(alpha=0.3); ax.legend(fontsize=8)
ax.set_title("far field of finite arrays built from the library", fontsize=10)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "05_farfield.png"), dpi=150); plt.close(fig)

# ================================================================ E. GIF: 12-atom array, short pulse
n_anim = 12
fw_anim = 0.4 * fcen
aperture = n_anim * LA
sx_a = aperture + 2 * 1.0 + 2 * DPML
sy_a = DPML + DSUB + H + 2.5 + DPML
yb = -0.5 * sy_a
ydev = yb + DPML + DSUB
geom = [mp.Block(center=mp.Vector3(0, yb + 0.5 * (DPML + DSUB)), size=mp.Vector3(mp.inf, DPML + DSUB), material=SiO2)]
for j in range(n_anim):
    xj = -0.5 * aperture + (j + 0.5) * LA
    geom.append(mp.Block(center=mp.Vector3(xj, ydev + 0.5 * H), size=mp.Vector3(w_lib[j % N_SEC], H), material=Si))
sim_a = mp.Simulation(resolution=RES, cell_size=mp.Vector3(sx_a, sy_a), boundary_layers=[mp.PML(DPML)], geometry=geom,
                      sources=[mp.Source(mp.GaussianSource(fcen, fwidth=fw_anim, is_integrated=True), component=mp.Ez,
                                         center=mp.Vector3(0, yb + DPML + 0.3), size=mp.Vector3(aperture, 0))])
sim_a.init_sim()
vol_a = mp.Volume(center=mp.Vector3(), size=mp.Vector3(sx_a - 2 * DPML, sy_a - 2 * DPML))
eps_a = sim_a.get_array(vol=vol_a, component=mp.Dielectric)
ext_a = [-(sx_a / 2 - DPML), sx_a / 2 - DPML, -(sy_a / 2 - DPML), sy_a / 2 - DPML]
t_src = 5 / fw_anim
frames, times = record_frames(sim_a, vol_a, mp.Ez, t_start=t_src - 1 / fw_anim, t_end=t_src + 1.2 * sy_a * 1.45, n_frames=60)
animate_fields(frames, times, ext_a, os.path.join(OUT, "06_anim_array.gif"), eps=eps_a, figsize=(6.0, 5.2), dpi=70,
               title=f"{n_anim}-atom array: wavefront leaves tilted toward +{THETA_D:.0f} deg", legend_loc="lower right")

if mp.am_master():
    with open(os.path.join(OUT, "result.json"), "w") as f:
        json.dump({"params": {"wl": wl, "La": LA, "Lambda": LAMBDA, "H": H, "theta_d_deg": THETA_D, "n_si": 3.45, "n_sio2": 1.45},
                   "library": {"widths": widths.tolist(), "amp40": amp40.tolist(), "phase40": ph40.tolist(), "amp60": amp60.tolist(),
                               "phase60": ph60.tolist(), "span40_over_2pi": span40 / (2 * np.pi), "max_dphi_60_40": float(np.max(np.abs(dphi)))},
                   "design": {"phi0": phi0, "targets": targets.tolist(), "widths": w_lib.tolist(), "amps": a_sel.tolist(), "min_amp": min_amp},
                   "supercell": {"orders": orders, "sum_orders": sum_orders, "T_total": T_total, "blazed_bound": BLAZED_BOUND,
                                 "plus1_over_bound": orders[1]["eff"] / BLAZED_BOUND},
                   "farfield": ff, "wall_s_total": time.time() - t_all, "meep": mp.__version__}, f, indent=2)
원본 실행 로그·재현 환경 보기

§4의 발췌 코드와 달리 전체 코드에는 far field·그림 저장·GIF 녹화·result.json 기록이 들어 있다. 그림 helper blogfig.py는 시리즈 공통이며 같은 폴더(code/)에 있다. 전체 코드와 helper: https://github.com/jin-castle/meep-examples/blob/main/code.

실행 결과 (2026-10-23 실행):

A. library H=0.9: phase span = 6.920 rad = 1.101 x 2pi; |t| in [0.689, 1.011]; monotonic: True; res 60 vs 40: max|dphi| = 0.817 rad, max d|t| = 0.071
B. design: phi0 = 0.797 rad, widths = [0.075, 0.1, 0.175, 0.225] um, |t| = [1.001, 0.959, 0.885, 0.885], min |t| = 0.885
C. supercell orders: m=-1: 0.1576 (-59.4 deg), m=0: 0.0325 (+0.0 deg), m=1: 0.5144 (+59.4 deg); sum = 0.7045, T_total = 0.7045; +1 efficiency 0.5144 = 63.5 % of the 4-level bound 0.8106
D. 10 atoms: aperture 4.50 um, main lobe +49.5 deg (design +59.44), est. beam width 38.8 deg
D. 40 atoms: aperture 18.00 um, main lobe +58.5 deg (design +59.44), est. beam width 9.7 deg

재현 환경: meep 1.33.0 · Python 3.11 · conda install -c conda-forge pymeep · 실행 python meta_atom.py (약 35 s, 단일 코어)

응용과 다음 학습 주제 보기

어디에 쓰이는가

meta-atom과 phase library는 metalens, 빔 조향기, 편광 분리기의 설계 흐름이다. 단위 셀 하나를 재고 배치해 소자를 만든다.

응용 이 글의 어떤 것을 쓰는가 그 다음에 필요한 것
metalens(스마트폰 카메라 두께, AR 디스플레이, 내시경) phase library → 위치별 위상 → 초점 35편 near2far 역설계
beam deflector(LiDAR, 광 스위치) 4단계 blazed 설계, supercell 효율 08편 metagrating 역설계
편광·색 분리 메타표면 같은 library 방법에 편광 축과 파장을 더한다 21편 비등방 재료
단위 셀 → 배치 → 검증의 설계 흐름 이 글 전체 —
]]>jin-castleMeep Example 08 · Metagrating inverse design — forward, adjoint, gradient, 검증의 4단계 계약2026-10-23T00:00:00+00:002026-10-23T00:00:00+00:00https://jin-castle.github.io/meep-examples/metagrating-inverse1. 먼저 보기: 같은 격자로 더 많은 빛을 보낼 수 있을까?

07편에서 고른 네 개의 Si 막대는 서로 다른 이웃과 만나면 library에서 예상한 응답과 달라집니다. 이번에는 한 주기 전체를 73개 밀도 변수로 열어, 오른쪽 위 +1차로 나가는 빛을 늘려 봅니다.

새 시뮬레이션에서 비교한 원래 격자와 갱신 격자의 차수별 효율 및 전기장
실제 별도 검증 결과입니다. +1차 효율은 0.4959에서 0.6228로 증가하고, 0차는 0.0666에서 0.0169로 줄었습니다. 그림을 누르면 원본을 확대할 수 있습니다.

개선과 수렴은 다릅니다. 이 결과는 MMA 5회 평가 중 가장 좋았던 3회차입니다. 73개 중 27개가 회색조이며, 최소 선폭·이진화 제약과 해상도 수렴 검증이 없어 제작 가능한 최적 설계로 볼 수 없습니다.

최적화한 격자를 다섯 주기 반복한 유한 배열에서 비스듬히 나가는 짧은 펄스
실제 펄스 전파 애니메이션입니다. 다섯 주기의 유한 배열에서 파면이 약 +59° 방향으로 기웁니다. 위 효율 표는 한 주기 주기경계 계산의 결과이므로 이 애니메이션 자체로 효율을 읽지는 않습니다.

2. 먼저 예측하기: gradient 방향이면 멀리 갈수록 좋을까?

현재 설계의 gradient 방향으로 한 번 움직일 때, step 크기 α를 계속 키우면?
예측과 실제 결과 비교하기

두 번째입니다. 원래 실행에서는 α = 0.8일 때 J = 0.6134까지 올랐지만, α = 2.0에서는 0.4840으로 출발점 0.4970보다 낮아졌습니다. gradient는 현재 설계 주변의 기울기이고 먼 설계의 성능을 보장하지 않습니다.

3. 원리 이해하기: 기울기를 검증한 뒤 재료를 바꾸기

밀도 ρ = 0은 공기, 1은 Si이며 사이는 유전율을 보간한 값입니다. 73개 변수는 가로 x 방향의 세로 띠를 바꿉니다. 한 띠의 높이 0.9 µm 전체는 같은 밀도를 사용하고 SiO₂ 기판은 고정합니다.

정방향 계산과 수반 계산으로 얻은 민감도로 73개 밀도를 갱신하고 별도 검증하는 개념도
설명용 개념도입니다. 기판 아래에서 +y 방향으로 입사하고 오른쪽 위 +1차를 목표로 합니다. forward와 adjoint는 별도 계산이며 회색 띠는 실제 최적화 결과가 아닙니다.
  1. Forward: 원래 광원으로 빛을 보내 +1차 모드 진폭을 구합니다.
  2. Adjoint: 목적함수에서 유도한 source를 출력 monitor에 놓고 별도 계산합니다.
  3. Gradient gate: 저장한 두 field와 재료의 밀도 의존성으로 구한 미분을 유한차분과 비교합니다.
  4. 갱신과 재측정: 먼저 손으로 한 걸음, 이어서 MMA로 갱신하고 새 시뮬레이션으로 차수별 power를 다시 잽니다.

목적함수는 J = |a₊₁|²/P_in입니다. 이 단일 주파수·단일 목적함수 예제에서는 forward와 adjoint 두 계산으로 모든 밀도의 미분을 얻습니다. 하지만 두 field의 밝기를 그냥 곱한 그림이 곧 최종 형상은 아닙니다.

73개 밀도에 대한 실제 signed gradient와 두 번째 막대 가장자리에 모인 큰 양의 민감도
실제 초기 gradient입니다. 빨강은 밀도를 올리면 J가 증가하는 방향, 파랑은 감소시키는 방향입니다. 큰 양의 값 다섯 개가 두 번째 막대 주변 x = −0.275~−0.175 µm에 모였습니다.

gate에서는 0/1 경계에서 떨어진 내부점과 gradient 방향을 사용합니다. 중심차분이 clipping으로 잘리지 않아야 같은 미분을 비교할 수 있습니다. 세 step의 상대오차는 0.68%, 0.12%, 0.06%로 기준 20%를 통과했습니다. 이는 이 설정에서의 미분 검증이며, 최적화나 해상도 수렴의 증명은 아닙니다.

모델 범위. 2D Ez, 파장 1.55 µm, x 주기경계·y PML, 해상도 40입니다. 설계 영역은 73 × 1이고 경계 평균·필터·투영을 사용하지 않습니다. 필터나 투영을 추가하면 그 mapping의 미분도 연결해야 합니다.

4. 직접 실행하기: 한 번의 step 크기만 바꾸기

Meep 1.33.0, nlopt, autograd가 준비된 환경에서 저장소의 code/ 폴더를 사용합니다. 전체 코드와 공통 helper는 아래 참고 자료에서 확인할 수 있습니다. 먼저 원본 실행을 보관합니다. 원래 기록은 단일 코어 약 48초입니다.

OMP_NUM_THREADS=1 python metagrating_inverse.py

이번 실험은 α = 2.0을 1.2로 바꾸는 것 하나입니다. 손 step을 순회하는 for alpha in (0.05, 0.3, 0.8, 2.0):에서 마지막 값만 1.2로 바꾸고 같은 명령으로 실행하세요. gradient·출발점·MMA 평가 수는 그대로 둡니다.

실행 로그의 one manual step에서 α = 0.8, 1.2의 J와 ΔJ를 비교하세요. α = 1.2는 0.8보다 멀리 움직이지만 더 좋아진다는 보장은 없습니다. 새 결과는 직접 측정해야 하며, 기존 α = 2.0의 0.4840을 새 결과로 사용하지 않습니다.

5. 결과 해석하기: 오른 것은 어떤 차수인가?

새 시뮬레이션의 측정값 원래 설계 갱신 설계
목표 +1차 효율 0.4959 0.6228
0차 효율 0.0666 0.0169
−1차 효율 0.1026 0.0973
차수 합 = 총 투과율 0.6651 0.7369

개선은 주로 0차 누설을 줄이는 데서 왔습니다. −1차는 거의 그대로입니다. 차수 합과 총 flux가 같은지도 함께 확인해야 차수 분해를 신뢰할 수 있습니다.

MMA 내부의 최고 J는 0.6241, 별도 검증의 +1차 효율은 0.6228입니다. 차이는 작지만, 보고하는 효율은 새 run에서 측정한 값입니다. 중간 4회차의 J = 0.0492처럼 평가가 나빠질 수 있으므로 마지막 평가 대신 보관한 최고 설계를 검증합니다.

6. 이해 확인하기

  1. gradient gate가 통과했는데도 큰 α에서 효율이 떨어질 수 있는 이유는 무엇인가요?
  2. 최종 효율로 MMA의 0.6241과 새 run의 0.6228 중 어느 값을 보고하고, 함께 확인할 것은 무엇인가요?
두 질문의 답 확인하기
  1. gate는 현재 내부점의 국소 미분을 검증합니다. 큰 이동에서는 선형 근사가 깨지고 밀도가 0/1로 clip될 수도 있어 성능 증가를 보장하지 않습니다.
  2. 새 run의 0.6228을 보고합니다. 차수 합과 총 flux의 일치, 최고 설계의 선택, 회색조와 해상도·제작 제약의 한계를 함께 확인합니다.

7. 참고 자료와 전체 코드

아래에는 원본의 자세한 설명·측정 표·실행 기록을 남겼습니다. 위의 한 가지 실험을 마친 뒤 필요한 항목을 펼쳐 보세요.

English summary

TL;DR (English)

격자의 빛을 원하는 방향으로 더 보내려면? — hero 원본 그림
  • What: the post-07 library design (four Si bars) becomes the starting point of an adjoint optimisation. The whole supercell period is a 1D design region of 73 density pixels; the objective is the +1-order efficiency. Four steps are enforced: differentiable materials, a finite-difference gate on the gradient, a short MMA run, and a fresh-simulation verification.
  • Result: the gradient passes the gate (0.7 %, 0.1 %, 0.06 % error at three step sizes). One hand-made gradient step lifts the efficiency from 0.497 to 0.613; five MMA evaluations reach 0.624. Measured again in a new simulation, order by order: +1 goes from 0.496 to 0.623 (61 % → 77 % of the 4-level bound), 0 drops from 0.067 to 0.017, −1 stays near 0.10.
  • Takeaway: adjoint gives you every pixel’s derivative for the price of two runs, but a wrong gradient fails silently. Gate it, take one step by hand before trusting an optimiser, and never report the optimiser’s own number: re-measure in a clean run. maxeval = 5 is a smoke test, not a converged design, and 27 of 73 pixels are still grey.
  • Code: full script at the bottom, ~48 s on one core.
배경·물리식·파라미터 자세히 보기

원본 §0 · 이 글에서 배우는 것

  • meep.adjoint의 세 요소: MaterialGrid 설계 변수, DesignRegion, EigenmodeCoefficient 목적함수를 묶는 OptimizationProblem
  • forward field와 adjoint field가 각각 무엇이고 gradient가 왜 둘의 곱인지
  • gradient gate: gradient 방향의 중심차분과 g·v를 비교하는 법, 그리고 랜덤 방향·경계점을 쓰면 왜 틀리는지
  • optimizer 전에 손으로 한 걸음 가 보기. step size가 커지면 선형 근사가 깨진다
  • MMA 5회의 의미와 한계. 회색조 픽셀은 재료가 아니다
  • 계약 4: optimizer 내부 FOM이 아니라 새 시뮬레이션의 차수별 power로 다시 재기

전제 지식: 07편의 library와 supercell, 06편의 DiffractedPlanewave. 공식 문서: Adjoint Solver 튜토리얼, adjoint 예제 01. 이전 글: 07 · Metalens의 meta-atom과 phase library · 다음 글: 09 · Waveguide bend inverse design

원본 §1 · 무엇을 알고 싶은가

07편의 4단계 설계는 +1차에 51%를 보냈고 상한 0.81의 63%였다. 모자란 이유는 library가 “이웃이 나와 같다”는 가정에서 나온 값이라는 것이었다. 그 가정을 버리고 73개 픽셀의 밀도를 전부 설계 변수로 열면 얼마나 회복되는가. 이것이 이 글의 질문이고, 답보다 중요한 것은 답을 믿어도 되는지 확인하는 절차다. adjoint 최적화는 gradient가 틀려도 에러 없이 조용히 엉뚱한 곳으로 수렴한다.

어디에 쓰이는가

metagrating은 LiDAR의 빔 조향과 대각도 회절 소자의 핵심이고, adjoint 역설계는 그 성능을 library 설계 너머로 올리는 표준 방법이다.

응용 이 글의 어떤 것을 쓰는가 그 다음에 필요한 것
LiDAR·빔 조향, 대각도 회절 +1차 효율 최대화, 이웃을 고려한 비국소 설계 —
모든 topology optimization 입문 adjoint 4단계 계약 09편, 32~36편
메타표면 제조 전 검증 fresh-run 검증, 회색조 문제 32편 filter·projection

원본 §2 · 물리 한 페이지

목적함수 J = |a₊₁|²/P_in은 73개 밀도 ρ의 함수다. 미분 ∂J/∂ρ_i를 하나씩 유한차분으로 구하면 146번의 시뮬레이션이 필요하다. adjoint 방법은 두 번으로 끝낸다. 원래 source로 쏜 forward field E_f와, 목적함수 monitor 자리에서 거꾸로 쏜 adjoint field E_a의 곱이 모든 픽셀의 gradient다. “빛이 실제로 지나는 곳”과 “목적함수가 민감한 곳”이 겹치는 픽셀에서 gradient가 크다.

\[\frac{\partial J}{\partial \rho_i}\;\propto\;\mathrm{Re}\big(E_f\cdot E_a\big)\Big\lvert _{\text{pixel } i},\qquad \text{gate: }\;\frac{\lvert \,g\cdot v - \mathrm{FD}_v\,\lvert }{\lvert \mathrm{FD}_v\lvert }\le 0.2,\quad v=\frac{g}{\lvert g\lvert },\quad \mathrm{FD}_v=\frac{J(x+sv)-J(x-sv)}{2s}\]

gate에서 두 가지를 지킨다. 방향 v는 gradient 방향이다. 설계 변수가 N개일 때 랜덤 방향과 gradient의 내적은 1/√N 크기라 방향미분이 작아지고 몇 %의 절대오차가 수십 %의 상대오차로 부풀려진다. 그리고 경계(ρ = 0, 1)에서 떨어진 내부점에서 잰다. 0/1 설계에서 x ± sv는 항목마다 한쪽이 clip되어 중심차분이 한쪽 미분만 세고, adjoint의 정확히 절반이 나온다. adjoint 오류가 아니라 FD의 결함이다.

기호 뜻 코드 변수
ρ (73개) 설계 밀도. 0 공기, 1 Si, 사이는 회색조 x_baseline, x_optimized
J +1차 효율 = |a₊₁|²/P_in fom(x)
g adjoint gradient ∂J/∂ρ g_baseline
v, s gate 방향(g/|g|), FD step v, steps
α 손 step 크기 one_step
k_diff +1차 평면파 방향 (1/Λ, √(f² − 1/Λ²)) kdiff

가정과 유효 범위: 2D Ez, 1D 설계 영역(높이 방향 1픽셀, 막대 높이 전체가 한 변수), 단일 주파수, eps_averaging=False로 경계 평균 없음. 제작 제약(최소 선폭, 이진화)은 없다.

결과 보기 전에 맞춰보기

물리량 내 예측 근거
gate 상대오차 1% 안 10_sources의 adjoint 튜토리얼 재현에서 2 × 10⁻⁶
gradient가 큰 곳 막대 가장자리 경계를 옮기는 것이 가장 효과가 크다
손 step α를 키우면 오르다가 꺾임 선형 근사의 한계
MMA 5회 0.497에서 0.6 근처로, 중간에 추락 가능 MMA가 신뢰영역을 넓게 잡았다 되돌림
별도 검증 vs optimizer FOM 소수 둘째 자리에서 다름 설계 격자(MaterialGrid 73 px)와 분해 monitor가 같아 비슷하지만 종료 조건이 다르다
회색조 픽셀 수십 개 이진화 없이 5회

판정 기준: gate 상대오차 > 20%면 HOLD. 그 뒤는 해석하지 않는다. 차수 합 ≠ 총 flux면 분해 오류.

원본 §3 · 시뮬레이션 설계도

07편 supercell과 같은 셀. 막대 자리가 1D `MaterialGrid` 설계 영역(폭 1.8 µm, 높이 0.9 µm, 73 픽셀)으로 바뀌었고 초기값은 library의 네 막대다. 빨간 가로선 = 기판 안 평면파, 파란
07편 supercell과 같은 셀. 막대 자리가 1D MaterialGrid 설계 영역(폭 1.8 µm, 높이 0.9 µm, 73 픽셀)으로 바뀌었고 초기값은 library의 네 막대다. 빨간 가로선 = 기판 안 평면파, 파란 가로선 = 목적함수 monitor(+1차 진폭), 녹색 빗금 = y PML, x는 주기 경계. 동그라미 숫자는 §4의 단계 번호다.
파라미터 값 왜 이 값인가 바꾸면
셀·주기·높이·해상도 07편과 동일 (1.8 × 4.9 µm, res 40) library를 그대로 초기값으로 쓰려면 모두 같아야 한다 하나라도 다르면 baseline이 07편 설계가 아니다
Nx 73 (25 nm 픽셀) 셀 폭 × res + 1 늘리면 변수는 늘지만 격자보다 가늘어져 의미 없다
decay_by 1e-6 adjoint run의 종료 기준. 느슨하면 adjoint만 무너진다(10_sources fdcheck) 1e-4면 adjoint gradient가 81% 틀어진다
gate steps 2e-3, 5e-3, 1e-2 절단오차와 반올림오차 사이 1e-6이면 반올림 반등
maxeval 5 수업용 smoke test 수렴을 보려면 수십 회 + 이진화
손 step α 0.05, 0.3, 0.8, 2.0 꺾이는 지점(0.8 근처) 포함 —
source 파형과 스펙트럼. 07편과 같다. 빈 기판 run에서 monitor 높이의 x 방향 위상 변화는 0.0000 rad로 수직 입사가 확인됐다.
source 파형과 스펙트럼. 07편과 같다. 빈 기판 run에서 monitor 높이의 x 방향 위상 변화는 0.0000 rad로 수직 입사가 확인됐다.

강의 노트북과의 차이: 없다. 4단계 계약, 파라미터, 수치(gate 0.0068/0.0012/0.0006, MMA 0.497 → 0.624, 검증 0.496 → 0.623) 모두 강의 week 9와 같다. 이 글은 10_sources의 두 fdcheck 노트에서 얻은 “gate가 깨지는 네 가지 이유”를 §6에 더했다.

원본 코드 단계별 설명

원본 §4 · 코드 따라가기

읽는 순서: 단위·파라미터 → 재료·구조 → source → Simulation·경계 → monitor → 실행·종료 → 후처리. 이번 글의 ⑤는 “목적함수”이고 ⑥·⑦은 forward·adjoint·gate·MMA·검증으로 늘어난다.

① 단위와 파라미터 — 어떤 숫자를 고정하는가

wl, fcen, fwidth = 1.55, 1 / 1.55, 0.1 / 1.55
N_SEC, LA = 4, 0.45; LAMBDA = N_SEC * LA; H = 0.9; RES = 40
W_LIB = np.array([0.075, 0.100, 0.175, 0.225])          # post-07 design (read from assets/07/result.json)
Nx, Ny = int(round(RES * LAMBDA)) + 1, 1                  # 73 x 1 design pixels
x_grid = np.linspace(-0.5 * LAMBDA, 0.5 * LAMBDA, Nx)
x_baseline = np.zeros(Nx)
for j, w in enumerate(W_LIB):
    xj = -0.5 * LAMBDA + (j + 0.5) * LA
    x_baseline[np.abs(x_grid - xj) <= 0.5 * w] = 1.0    # the four bars, as 0/1 densities
  • 무엇: 07편 파라미터를 그대로 두고, library 설계를 73개 0/1 밀도로 옮긴다.
  • 왜: 출발점이 랜덤이 아니라 “이미 괜찮은 설계”여야 “adjoint가 간극을 얼마나 메우는가”를 물을 수 있다. 랜덤 회색조는 +1차 효율 0.018에서 시작한다(§5).
  • 틀리면: 픽셀 폭 25 nm와 library 폭(0.075 = 3 px)이 맞지 않으면 baseline이 07편과 다른 구조가 된다.

② 재료와 구조 — 무엇이 어디에 있는가

design_variables = mp.MaterialGrid(mp.Vector3(Nx, Ny), mp.air, Si, grid_type="U_MEAN", do_averaging=False)   # contract 1
design_region = mpa.DesignRegion(design_variables,
                                 volume=mp.Volume(center=mp.Vector3(0, Y_DEV + 0.5 * H), size=mp.Vector3(LAMBDA, H)))
geometry = [mp.Block(..., material=SiO2),                                   # substrate
            mp.Block(center=design_region.center, size=design_region.size, material=design_variables)]
sim = mp.Simulation(geometry=geometry, eps_averaging=False, **common)
  • 무엇: 막대 대신 밀도 격자. MaterialGrid는 ρ = 0이면 공기, 1이면 Si, 사이는 선형 보간된 유전율이다.
  • 왜: 미분하려면 유전율이 ρ의 매끄러운 함수여야 한다. do_averaging=False와 eps_averaging=False가 계약 1이다.
  • 틀리면: eps_averaging을 기본값(True)으로 두면 Meep이 경계에서 유전율을 평균해 gradient와 실제 구조가 어긋난다.

③ Source — 빛을 어떻게 넣는가

sources = [mp.Source(mp.GaussianSource(fcen, fwidth=fwidth), component=mp.Ez, center=mp.Vector3(0, SRC_Y), size=mp.Vector3(LAMBDA, 0))]
adjoint_sources = opt.adjoint_sources[0]      # what opt actually fired for the adjoint run (an EigenModeSource at the monitor)
  • 무엇: forward는 07편과 같은 평면파. adjoint source는 OptimizationProblem이 목적함수 monitor 자리에 스스로 만든다.
  • 왜: adjoint source의 진폭과 모양은 목적함수의 미분값으로 정해진다. 우리가 고르는 게 아니라 opt가 계산한 것을 꺼내 볼 뿐이다.
  • 틀리면: 빈 기판 run에서 monitor 높이의 위상이 x를 따라 변하면 source가 기울어진 것이고 “+1차 효율”이라는 말이 성립하지 않는다.

④ Simulation과 경계 — 계산 상자와 PML

common = dict(resolution=RES, cell_size=mp.Vector3(LAMBDA, SY), sources=sources,
              boundary_layers=[mp.PML(thickness=DPML, direction=mp.Y)], k_point=mp.Vector3())
  • 무엇: 07편 supercell과 같다. x 주기, y PML.
  • 왜: 모든 run(forward, adjoint, FD, 검증)이 같은 셀을 써야 비교가 된다.
  • 틀리면: 검증 run의 셀이 다르면 “optimizer FOM과 다르다”가 설계 때문인지 셀 때문인지 모른다.

⑤ Monitor — 목적함수

kdiff = mp.Vector3(1 / LAMBDA, np.sqrt(fcen ** 2 - (1 / LAMBDA) ** 2))          # +1 order direction
emc = mpa.EigenmodeCoefficient(sim, mp.Volume(center=mp.Vector3(0, MON_Y), size=mp.Vector3(LAMBDA, 0)), mode=1,
                               eig_parity=mp.ODD_Z, kpoint_func=lambda *_: kdiff,
                               eig_vol=mp.Volume(center=mp.Vector3(0, MON_Y), size=mp.Vector3(1 / RES, 0, 0)))
opt = mpa.OptimizationProblem(simulation=sim, objective_functions=lambda e: npa.abs(e[0]) ** 2,
                              objective_arguments=[emc], design_regions=[design_region], fcen=fcen, df=0, nf=1, decay_by=1e-6)
  • 무엇: monitor 선 위의 +1차 평면파 진폭 a₊₁을 목적함수 인자로, |a₊₁|²를 목적함수로.
  • 왜: kpoint_func가 +1차 방향을 지정하고, eig_vol을 한 픽셀로 잡아 “평면파”임을 알린다(06편의 DiffractedPlanewave에 해당). npa(autograd의 numpy)로 써야 목적함수 자체가 미분된다.
  • 틀리면: eig_parity를 빼면 다른 편광 모드가 섞인다. decay_by를 1e-4로 느슨하게 하면 forward와 FD는 멀쩡한데 adjoint gradient만 81% 틀어진다(10_sources fdcheck E4).

⑥ 실행 — forward, adjoint, gate, 한 걸음, MMA

f, dJ = opt([x], need_gradient=True)            # forward + adjoint: J and dJ/drho for all 73 pixels

x_gate = np.clip(x_baseline, 0.02, 0.98)         # interior point, away from 0/1
v = g_gate / np.linalg.norm(g_gate)              # gradient direction
fd = (fom(x_gate + s * v) - fom(x_gate - s * v)) / (2 * s)
ok = abs(g_gate @ v - fd) / abs(fd) <= 0.20

x_try = np.clip(x_baseline + alpha * g / np.linalg.norm(g), 0, 1)    # one step by hand

solver = nlopt.opt(nlopt.LD_MMA, Nx); solver.set_lower_bounds(0); solver.set_upper_bounds(1)
solver.set_max_objective(nlopt_objective); solver.set_maxeval(5)
  • 무엇: opt(...) 한 번이 forward와 adjoint 두 run이다. gate는 세 step으로 중심차분. 그다음 손으로 한 걸음, 그다음 MMA 5회.
  • 왜: 순서가 계약이다. gate를 통과하지 못한 gradient로는 아무것도 하지 않는다. 손 step은 “gradient 방향으로 가면 정말 오르는가, 얼마나 멀리까지”를 보여 준다.
  • 틀리면: 0/1 baseline에서 바로 gate를 재면 clip 때문에 FD가 adjoint의 절반이 나와 HOLD가 된다. 랜덤 방향으로 재면 상대오차가 1/√73 배로 부풀려진다.

⑦ 후처리 — 계약 4, 별도 검증

def forward_orders(weights):
    s = mp.Simulation(geometry=geometry_with(weights), eps_averaging=False, **common)   # a NEW simulation
    mon = s.add_mode_monitor(fcen, 0, 1, mp.ModeRegion(center=mp.Vector3(0, MON_Y), size=mp.Vector3(LAMBDA, 0)))
    s.run(until_after_sources=stop_cond)
    eff = {m: abs(s.get_eigenmode_coefficients(mon, mp.DiffractedPlanewave((m, 0, 0), mp.Vector3(1, 0, 0), 1, 0)).alpha[0, 0, 0]) ** 2 / input_flux
           for m in (-1, 0, 1)}
    return eff, mp.get_fluxes(mon)[0] / input_flux
  • 무엇: 최종 설계를 새 Simulation에 넣고 06편 방식으로 세 차수를 다시 잰다. 차수 합 = 총 flux도 검산한다.
  • 왜: optimizer 안의 FOM은 그 optimizer의 종료 조건·monitor 설정에 묶인 숫자다. 보고할 값은 독립 run의 값이어야 한다.
  • 틀리면: optimizer FOM(0.624)을 그대로 쓰면 검증값(0.623)과 미세하게 다르다. 이번엔 작지만 조건이 다르면 커진다.

함정: 여기서 설계 변수는 x에 대한 밀도 하나뿐이고 mapping(필터·투영)이 없다. mapping을 넣으면 gradient에 chain rule을 걸어야 하고, 빠뜨리면 gate의 cosine이 −0.45로 방향이 반대가 된다(10_sources fdcheck E5).

원본 결과·검증 표·오류 진단·추가 탐구

원본 §5 · 결과

왼쪽: library baseline의 forward field. 파면이 위로 갈수록 오른쪽으로 기운다(+1차). 가운데: 랜덤 회색조 출발점. 파면이 뭉개지고 J = 0.018이다. 오른쪽: adjoint field. monitor
왼쪽: library baseline의 forward field. 파면이 위로 갈수록 오른쪽으로 기운다(+1차). 가운데: 랜덤 회색조 출발점. 파면이 뭉개지고 J = 0.018이다. 오른쪽: adjoint field. monitor에서 아래로 내려오는 파. 절대 크기는 비교하지 않는다. 볼 것은 “어디에 있는가”다.
baseline에서의 날것 gradient. 빨강은 밀도를 올리면 J가 오르는 자리, 파랑은 반대. 절대값이 큰 5개가 모두 두 번째 막대(x = −0.275~−0.175) 가장자리에 몰려 있다. 막대를 넓히라는 뜻이다.
baseline에서의 날것 gradient. 빨강은 밀도를 올리면 J가 오르는 자리, 파랑은 반대. 절대값이 큰 5개가 모두 두 번째 막대(x = −0.275~−0.175) 가장자리에 몰려 있다. 막대를 넓히라는 뜻이다.
gradient gate. 세 step 모두 FD와 adjoint가 1% 안에서 같다. PASS.
gradient gate. 세 step 모두 FD와 adjoint가 1% 안에서 같다. PASS.
step FD adjoint g·v 상대오차
2e-3 0.5410 0.5447 0.0068
5e-3 0.5454 0.5447 0.0012
1e-2 0.5451 0.5447 0.0006
위: 손으로 한 걸음(α sweep)과 MMA history. α = 0.8까지 오르다 2.0에서 떨어진다. 아래: MMA 다섯 번의 설계. 3번째에서 0.624, 4번째에서 0.049로 추락했다가 5번째에 0.540으로 돌아온다.
위: 손으로 한 걸음(α sweep)과 MMA history. α = 0.8까지 오르다 2.0에서 떨어진다. 아래: MMA 다섯 번의 설계. 3번째에서 0.624, 4번째에서 0.049로 추락했다가 5번째에 0.540으로 돌아온다. 가장 좋은 3번째를 최종으로 둔다.
α J ΔJ
0.05 0.5075 +0.011
0.3 0.5549 +0.058
0.8 0.6134 +0.116
2.0 0.4840 −0.013
계약 4. 새 시뮬레이션에서 잰 차수별 효율(왼쪽)과 baseline·optimized의 Re(Ez)(가운데·오른쪽). 빨간 점선이 4단계 blazed 상한.
계약 4. 새 시뮬레이션에서 잰 차수별 효율(왼쪽)과 baseline·optimized의 Re(Ez)(가운데·오른쪽). 빨간 점선이 4단계 blazed 상한.
설계 m = −1 m = 0 m = +1 차수 합 총 투과 +1 / 상한
baseline (07편 library) 0.1026 0.0666 0.4959 0.6651 0.6651 61.2%
optimized (MMA eval 3) 0.0973 0.0169 0.6228 0.7369 0.7369 76.8%

예측과 비교

물리량 내 예측 (§2) 시뮬레이션 판정
gate 상대오차 1% 안 0.7%, 0.1%, 0.06% ✅
gradient 큰 곳 막대 가장자리 두 번째 막대 양 끝 ✅
손 step 오르다 꺾임 0.8에서 최대, 2.0에서 하락 ✅
MMA 5회 0.6 근처, 중간 추락 0.624, 4회차 0.049 ✅
검증 vs optimizer 둘째 자리 차이 0.6228 vs 0.6241 ✅
회색조 수십 개 27 / 73 ✅

예측대로였고, 숫자로 확인된 것은 두 가지다. 07편의 “이웃이 같다” 가정이 잃던 몫의 절반 가까이를 픽셀 자유도가 되찾았다(61% → 77%). 그리고 그 개선의 대부분은 0차 누설을 줄인 데서 왔다(0.067 → 0.017). −1차는 거의 그대로다. 계단 근사의 거울상 누설은 5회로는 못 건드렸다.

수렴성

이 글의 수렴성은 해상도가 아니라 gate의 세 step이다. step을 5배 바꿔도 FD가 0.541~0.545에서 안정이고 adjoint와 1% 안에 있다. 해상도 의존성은 07편의 library 수렴성(위상 0.82 rad 변동)이 그대로 이 설계에 옮겨 온다. res 60으로 다시 돌리면 baseline 효율부터 달라진다.

주장할 수 있는 것 / 없는 것

  • 할 수 있는 것: 이 셀·해상도에서 adjoint gradient는 유한차분과 1% 안에서 같다. library baseline에서 다섯 번의 MMA 평가로 +1차 효율이 0.50에서 0.62로 올랐고, 그 값은 별도 run으로 재확인됐다.
  • 할 수 없는 것: “최적 설계를 찾았다”. maxeval 5는 수렴이 아니다. 73개 중 27개가 회색조라 이 패턴은 실제 소자가 아니다. 최소 선폭 제약이 없어 이진화하면 효율이 달라진다. 다른 해상도·파장·편광에서의 값.

원본 §6 · 흔한 실수

증상 원인 고치는 법
gate에서 FD가 adjoint의 정확히 1/2 0/1 경계점에서 clip된 중심차분 내부점(0.02~0.98)에서 재기
gate 상대오차 수십 % 랜덤 방향 사용 gradient 방향 v = g/|g|
gate에서 adjoint만 틀어짐 decay_by 느슨함 1e-6 이하
gate cosine이 음수 mapping(필터·투영)의 chain rule 누락 gradient에 mapping의 Jacobian 곱하기
optimizer FOM과 검증값이 다름 조건이 다른 run 보고는 항상 새 run의 값으로
MMA가 중간에 추락 신뢰영역 과대 정상 동작. 최고 평가를 보관
회색조 설계를 소자로 해석 이진화·선폭 제약 없음 09편 이후: 필터·투영·β 스케줄

원본 §7 · 직접 해보기

바꿀 것 예상 변화 확인할 수치
초기값을 균일 0.5로 격자가 없어 +1차 0인 퇴화점. gradient가 어떻게 나오는지 g, gate
maxeval 5 → 30 효율이 어디서 정체하는지 history
목적함수를 |a₊₁|² − |a₋₁|²로 −1차 누설이 줄어드는지 검증 표
gate에서 decay_by 1e-6 → 1e-4 adjoint만 틀어지는 것을 재현 상대오차
metagrating_inverse.py (클릭해서 펼치기) 
"""Meep Example 08 - Metagrating inverse design (adjoint), with a four-step contract.

Start from the post-07 library design (four Si bars). Open the whole supercell period as a 1D design
region (73 pixels of density 0..1) and let the adjoint gradient move it. Every step is looked at:
  1. differentiability: eps_averaging=False, MaterialGrid do_averaging=False
  2. gradient gate: adjoint gradient vs centred finite differences along the gradient direction
  3. a short MMA run (maxeval 5): a smoke test, not a converged design
  4. verification in a FRESH simulation with DiffractedPlanewave, order by order
Plus: forward field of baseline and of a random start, adjoint field, raw gradient, one manual step.

Run:  python metagrating_inverse.py      (~1.5 min on one core)
Out:  00_source.png, 01_layout.png, 02_fields.png, 03_gradient.png, 04_gate.png, 05_step_mma.png,
      06_verify.png, 07_anim_optimized.gif, result.json   (-> ../assets/08/)
"""
import json
import os
import sys
import time

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import meep as mp
import meep.adjoint as mpa
import nlopt
from autograd import numpy as npa

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from blogfig import Label, animate_fields, annotated_layout, record_frames, source_figure   # noqa: E402

HERE = os.path.dirname(os.path.abspath(__file__))
OUT = os.path.join(HERE, "..", "assets", "08")
os.makedirs(OUT, exist_ok=True)
t_all = time.time()
np.random.seed(20260815)

# ---------------------------------------------------------------- (1) units & parameters: identical to post 07
wl = 1.55
fcen = 1 / wl
fwidth = 0.1 * fcen
Si, SiO2 = mp.Medium(index=3.45), mp.Medium(index=1.45)
N_SEC, LA = 4, 0.45
LAMBDA = N_SEC * LA
THETA_D = float(np.degrees(np.arcsin(wl / LAMBDA)))
H = 0.9
RES = 40
DPML, DSUB, DAIR = 1.0, 1.0, 1.0
SY = DPML + DSUB + H + DAIR + DPML
Y_BOT = -0.5 * SY
Y_DEV = Y_BOT + DPML + DSUB
SRC_Y = Y_BOT + DPML + 0.3
MON_Y = -Y_BOT - DPML - 0.3
BLAZED_BOUND = (np.sin(np.pi / N_SEC) / (np.pi / N_SEC)) ** 2
EXTENT = [-0.5 * LAMBDA, 0.5 * LAMBDA, Y_BOT, -Y_BOT]

# baseline widths: post-07 library design (read from its result.json if present)
try:
    with open(os.path.join(HERE, "..", "assets", "07", "result.json")) as f:
        W_LIB = np.array(json.load(f)["design"]["widths"])
except Exception:
    W_LIB = np.array([0.075, 0.100, 0.175, 0.225])

sources = [mp.Source(mp.GaussianSource(fcen, fwidth=fwidth), component=mp.Ez, center=mp.Vector3(0, SRC_Y), size=mp.Vector3(LAMBDA, 0))]
common = dict(resolution=RES, cell_size=mp.Vector3(LAMBDA, SY), sources=sources,
              boundary_layers=[mp.PML(thickness=DPML, direction=mp.Y)], k_point=mp.Vector3())
stop_cond = mp.stop_when_fields_decayed(10, mp.Ez, mp.Vector3(0, MON_Y), 1e-7)

# ---------------------------------------------------------------- (2) geometry: substrate + a 1D MaterialGrid design region
Nx, Ny = int(round(RES * LAMBDA)) + 1, 1
x_grid = np.linspace(-0.5 * LAMBDA, 0.5 * LAMBDA, Nx)
design_variables = mp.MaterialGrid(mp.Vector3(Nx, Ny), mp.air, Si, grid_type="U_MEAN", do_averaging=False)   # contract 1
design_region = mpa.DesignRegion(design_variables, volume=mp.Volume(center=mp.Vector3(0, Y_DEV + 0.5 * H), size=mp.Vector3(LAMBDA, H)))
x_baseline = np.zeros(Nx)
for j, w in enumerate(W_LIB):
    xj = -0.5 * LAMBDA + (j + 0.5) * LA
    x_baseline[np.abs(x_grid - xj) <= 0.5 * w] = 1.0


def geometry_with(weights):
    grid = mp.MaterialGrid(mp.Vector3(Nx, Ny), mp.air, Si, weights=np.asarray(weights).reshape(Nx, Ny), grid_type="U_MEAN", do_averaging=False)
    return [mp.Block(center=mp.Vector3(0, Y_BOT + 0.5 * (DPML + DSUB)), size=mp.Vector3(mp.inf, DPML + DSUB), material=SiO2),
            mp.Block(center=design_region.center, size=design_region.size, material=grid)]


geometry = [mp.Block(center=mp.Vector3(0, Y_BOT + 0.5 * (DPML + DSUB)), size=mp.Vector3(mp.inf, DPML + DSUB), material=SiO2),
            mp.Block(center=design_region.center, size=design_region.size, material=design_variables)]

# ---------------------------------------------------------------- (4) simulation + (5) objective: +1 order amplitude
sim = mp.Simulation(geometry=geometry, eps_averaging=False, **common)
kdiff = mp.Vector3(1 / LAMBDA, np.sqrt(fcen ** 2 - (1 / LAMBDA) ** 2))      # +1 order direction
emc = mpa.EigenmodeCoefficient(sim, mp.Volume(center=mp.Vector3(0, MON_Y), size=mp.Vector3(LAMBDA, 0)), mode=1,
                               eig_parity=mp.ODD_Z, kpoint_func=lambda *_: kdiff,
                               eig_vol=mp.Volume(center=mp.Vector3(0, MON_Y), size=mp.Vector3(1 / RES, 0, 0)))
opt = mpa.OptimizationProblem(simulation=sim, objective_functions=lambda e: npa.abs(e[0]) ** 2, objective_arguments=[emc],
                              design_regions=[design_region], fcen=fcen, df=0, nf=1, decay_by=1e-6)
opt.update_design([x_baseline])
annotated_layout(
    sim, os.path.join(OUT, "01_layout.png"), dpml=DPML, figsize=(5.2, 7.0), axis_step=0.5,
    title="supercell: 1D design region (73 px) replaces the bars",
    params_text=f"wl={wl} res={RES}\nLambda={LAMBDA} H={H}\nNx={Nx} (25 nm px)",
    params_xy=(-0.85, 2.35), pml_xy=(-0.5, Y_BOT + 0.5 * DPML), decay_point=(0, MON_Y), decay_text_xy=(-0.1, 1.75),
    labels=[Label("design region: MaterialGrid, baseline = library bars", (-0.3, Y_DEV + 0.5 * H), (-0.85, 1.25), step=2, color="black"),
            Label("plane wave in SiO2", (0.3, SRC_Y), (-0.85, SRC_Y - 0.35), step=3, color="red"),
            Label("objective: |a_+1|^2 on this line", (0.5, MON_Y), (-0.85, MON_Y + 0.35), step=5, color="blue")])
source_figure(fcen, fwidth, os.path.join(OUT, "00_source.png"), wl_scale=1000.0, wl_unit="nm", time_unit="um/c")


def run_dft_field(src_list, geometry_list):
    s = mp.Simulation(geometry=geometry_list, eps_averaging=False, **dict(common, sources=src_list))
    dft = s.add_dft_fields([mp.Ez], fcen, 0, 1, center=mp.Vector3(), size=mp.Vector3(LAMBDA, SY))
    s.run(until_after_sources=stop_cond)
    field = s.get_dft_array(dft, mp.Ez, 0); eps = s.get_epsilon(); s.reset_meep()
    return field, eps


# ---------------------------------------------------------------- source check + input flux (empty substrate)
sim_ref = mp.Simulation(default_material=SiO2, **common)
fl = sim_ref.add_mode_monitor(fcen, 0, 1, mp.ModeRegion(center=mp.Vector3(0, MON_Y), size=mp.Vector3(LAMBDA, 0)))
dft_ref = sim_ref.add_dft_fields([mp.Ez], fcen, 0, 1, center=mp.Vector3(), size=mp.Vector3(LAMBDA, SY))
sim_ref.run(until_after_sources=stop_cond)
input_flux = float(mp.get_fluxes(fl)[0])
field_ref = sim_ref.get_dft_array(dft_ref, mp.Ez, 0)
sim_ref.reset_meep()
row = field_ref[:, field_ref.shape[1] // 2]
phase_spread = float(np.ptp(np.unwrap(np.angle(row))))
print(f"source check: input_flux = {input_flux:.5e}, phase spread across x at mid-height = {phase_spread:.4f} rad ({'normal incidence' if phase_spread < 0.2 else 'TILTED'})")


def fom(x, need_gradient=False):
    """+1 order efficiency = |a_+1|^2 / input_flux (and its gradient w.r.t. the 73 densities)."""
    f, dJ = opt([np.clip(x, 0, 1)], need_gradient=need_gradient)
    f = float(np.real(np.asarray(f).squeeze())) / input_flux
    if not need_gradient:
        return f
    return f, np.squeeze(np.asarray(dJ)) / input_flux


# ---------------------------------------------------------------- forward fields: baseline vs random start; adjoint field
field_fwd, eps_fwd = run_dft_field(sources, geometry_with(x_baseline))
f_baseline, g_baseline = fom(x_baseline, need_gradient=True)
x_random = np.random.rand(Nx)
field_rand, eps_rand = run_dft_field(sources, geometry_with(x_random))
f_random = fom(x_random)
adjoint_sources = opt.adjoint_sources[0]
field_adj, eps_adj = run_dft_field(adjoint_sources, geometry_with(x_baseline))
print(f"forward: baseline +1 efficiency = {f_baseline:.4f} (|grad| = {np.linalg.norm(g_baseline):.3e}); random grayscale start = {f_random:.4f}; "
      f"adjoint sources: {len(adjoint_sources)} x {type(adjoint_sources[0]).__name__}")

xs = np.linspace(EXTENT[0], EXTENT[1], eps_fwd.shape[0]); ys = np.linspace(EXTENT[2], EXTENT[3], eps_fwd.shape[1])
fig, ax = plt.subplots(2, 3, figsize=(10.5, 7.2))
lim = max(np.max(np.abs(field_fwd)), np.max(np.abs(field_rand)))
for col, (fld, eps, ttl) in enumerate(((field_fwd, eps_fwd, f"forward, baseline (library bars)  J = {f_baseline:.3f}"),
                                       (field_rand, eps_rand, f"forward, random grayscale start  J = {f_random:.3f}"),
                                       (field_adj, eps_adj, "adjoint: source placed at the objective monitor"))):
    l = lim if col < 2 else float(np.max(np.abs(fld)))
    ax[0, col].imshow(np.real(fld).T, extent=EXTENT, origin="lower", cmap="RdBu", vmin=-l, vmax=l, aspect="equal")
    ax[1, col].imshow(np.abs(fld).T, extent=EXTENT, origin="lower", cmap="inferno", aspect="equal")
    for a in ax[:, col]:
        a.contour(xs, ys, eps.T, levels=[1.5, 6.0], colors="w", linewidths=0.6); a.set_xlabel("x [um]")
    ax[0, col].set_title(ttl, fontsize=8.5)
ax[0, 0].set_ylabel("Re(Ez)  y [um]"); ax[1, 0].set_ylabel("|Ez|  y [um]")
fig.suptitle("the field follows the design; the adjoint field flows from the monitor back down", fontsize=10)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "02_fields.png"), dpi=150); plt.close(fig)

# ---------------------------------------------------------------- raw gradient
fig, ax = plt.subplots(2, 1, figsize=(9, 4.8), sharex=True)
ax[0].plot(x_grid, g_baseline, lw=1.2, color="tab:purple"); ax[0].axhline(0, color="k", lw=0.7)
ax[0].fill_between(x_grid, 0, g_baseline, where=g_baseline > 0, color="tab:red", alpha=0.25, label="increase density here")
ax[0].fill_between(x_grid, 0, g_baseline, where=g_baseline < 0, color="tab:blue", alpha=0.25, label="decrease density here")
ax[0].set_ylabel("dJ / d(density)"); ax[0].set_title("raw adjoint gradient at the baseline (no filtering)", fontsize=9); ax[0].legend(fontsize=8, loc="upper right")
ax[1].step(x_grid, x_baseline, where="mid", color="tab:gray", lw=1.3); ax[1].fill_between(x_grid, 0, x_baseline, step="mid", color="tab:gray", alpha=0.35)
ax[1].set_ylabel("density (0 = air, 1 = Si)"); ax[1].set_xlabel("x [um]"); ax[1].set_ylim(-0.05, 1.15); ax[1].set_title("current design", fontsize=9)
for a in ax:
    for j in range(1, N_SEC):
        a.axvline(-0.5 * LAMBDA + j * LA, color="k", ls=":", lw=0.8)
    a.grid(alpha=0.3)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "03_gradient.png"), dpi=150); plt.close(fig)
top = sorted(np.argsort(np.abs(g_baseline))[::-1][:5])
print("gradient: largest 5 |dJ/drho| at x = " + ", ".join(f"{x_grid[i]:+.3f} ({g_baseline[i]:+.3f}, rho={x_baseline[i]:.0f})" for i in top))

# ---------------------------------------------------------------- contract 2: gradient gate (interior point, gradient direction)
x_gate = np.clip(x_baseline, 0.02, 0.98)
f_gate, g_gate = fom(x_gate, need_gradient=True)
v = g_gate / np.linalg.norm(g_gate)
adjoint_dd = float(np.dot(g_gate, v))
steps = [2e-3, 5e-3, 1e-2]
gate_rows = []
for step in steps:
    fd = (fom(x_gate + step * v) - fom(x_gate - step * v)) / (2 * step)
    rel = abs(adjoint_dd - fd) / max(abs(fd), 1e-30)
    gate_rows.append({"step": step, "fd": fd, "adjoint": adjoint_dd, "rel_err": rel, "pass": bool(rel <= 0.20 and np.sign(fd) == np.sign(adjoint_dd))})
gradient_gate = all(r["pass"] for r in gate_rows)
print(f"gate: interior-point FOM = {f_gate:.4f}; " + "; ".join(f"step {r['step']:.0e}: FD {r['fd']:.4e} vs adjoint {r['adjoint']:.4e}, rel {r['rel_err']:.4f} {'PASS' if r['pass'] else 'HOLD'}" for r in gate_rows)
      + f" -> gradient gate {'PASS' if gradient_gate else 'HOLD'}")
fig, ax = plt.subplots(1, 2, figsize=(10, 3.4))
idx = np.arange(len(steps))
ax[0].bar(idx - 0.2, [r["fd"] for r in gate_rows], width=0.4, color="tab:orange", label="centred finite difference")
ax[0].bar(idx + 0.2, [adjoint_dd] * 3, width=0.4, color="tab:blue", label="adjoint  g . v")
ax[0].set_xticks(idx); ax[0].set_xticklabels([f"{s:.0e}" for s in steps]); ax[0].set_xlabel("finite-difference step"); ax[0].set_ylabel("directional derivative")
ax[0].set_title("adjoint vs finite difference along the gradient direction", fontsize=9); ax[0].grid(axis="y", alpha=0.3); ax[0].legend(fontsize=8)
bars = ax[1].bar(idx, [r["rel_err"] for r in gate_rows], color=["tab:green" if r["pass"] else "tab:red" for r in gate_rows])
ax[1].axhline(0.20, ls="--", color="crimson", lw=1.2, label="gate: 20 %")
for b, r in zip(bars, gate_rows):
    ax[1].text(b.get_x() + b.get_width() / 2, r["rel_err"] + 0.004, f"{r['rel_err']:.4f}", ha="center", fontsize=8)
ax[1].set_xticks(idx); ax[1].set_xticklabels([f"{s:.0e}" for s in steps]); ax[1].set_ylim(0, 0.25); ax[1].set_ylabel("relative error")
ax[1].set_title(f"gradient gate: {'PASS' if gradient_gate else 'HOLD'}", fontsize=9); ax[1].grid(axis="y", alpha=0.3); ax[1].legend(fontsize=8)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "04_gate.png"), dpi=150); plt.close(fig)
if not gradient_gate:
    raise SystemExit("gradient gate HOLD: do not interpret optimizer results")

# ---------------------------------------------------------------- one manual step, then MMA (contract 3)
direction = g_baseline / np.linalg.norm(g_baseline)
one_step = []
for alpha in (0.05, 0.3, 0.8, 2.0):
    x_try = np.clip(x_baseline + alpha * direction, 0, 1)
    one_step.append((alpha, x_try, fom(x_try)))
print("one manual step: " + ", ".join(f"alpha {a} -> {f:.4f} ({f - f_baseline:+.4f})" for a, _, f in one_step))

history, design_history = [], []


def nlopt_objective(x, grad):
    f, dJ = fom(x, need_gradient=True)
    if grad.size > 0:
        grad[:] = dJ
    history.append(f); design_history.append(np.array(x, copy=True))
    return f


solver = nlopt.opt(nlopt.LD_MMA, Nx)
solver.set_lower_bounds(np.zeros(Nx)); solver.set_upper_bounds(np.ones(Nx))
solver.set_max_objective(nlopt_objective); solver.set_maxeval(5)
x_optimized = np.clip(solver.optimize(x_baseline.copy()), 0, 1)
best_k = int(np.argmax(history))
x_optimized = design_history[best_k]                         # keep the best evaluated design (MMA may overshoot)
gray = int(np.sum((x_optimized > 0.02) & (x_optimized < 0.98)))
print("MMA (maxeval 5): " + ", ".join(f"eval {k+1}: {f:.4f}" for k, f in enumerate(history)) + f"; best eval {best_k+1} = {max(history):.4f} ({max(history)/history[0]:.3f}x); grayscale pixels {gray}/{Nx}")

fig = plt.figure(figsize=(14, 6.2))
gs = fig.add_gridspec(2, 6, height_ratios=[1, 1])
axs = [fig.add_subplot(gs[0, k]) for k in range(5)]
axs[0].step(x_grid, x_baseline, where="mid", color="tab:gray", lw=1.1); axs[0].fill_between(x_grid, 0, x_baseline, step="mid", color="tab:gray", alpha=0.4)
axs[0].set_title(f"baseline\nJ = {f_baseline:.4f}", fontsize=8); axs[0].set_ylabel("density")
for a, (alpha, x_try, f_try) in zip(axs[1:], one_step):
    a.step(x_grid, x_try, where="mid", color="tab:green", lw=1.1); a.fill_between(x_grid, 0, x_try, step="mid", color="tab:green", alpha=0.4)
    a.set_title(f"one step, alpha = {alpha}\nJ = {f_try:.4f}", fontsize=8)
for a in axs:
    a.set_ylim(-0.05, 1.08); a.set_xlabel("x [um]"); a.grid(alpha=0.3)
axh = fig.add_subplot(gs[0, 5])
axh.plot(range(1, len(history) + 1), history, "o-", color="tab:blue"); axh.axhline(f_baseline, ls="--", color="gray", lw=1, label="baseline")
axh.set_xticks(range(1, len(history) + 1)); axh.set_xlabel("MMA evaluation"); axh.set_ylabel("+1 efficiency"); axh.set_title("MMA history", fontsize=8); axh.grid(alpha=0.3); axh.legend(fontsize=7)
for k in range(len(design_history)):
    a = fig.add_subplot(gs[1, k])
    a.step(x_grid, design_history[k], where="mid", color="tab:blue", lw=1.0); a.fill_between(x_grid, 0, design_history[k], step="mid", color="tab:blue", alpha=0.4)
    a.set_title(f"MMA eval {k + 1}  J = {history[k]:.4f}" + ("  (kept)" if k == best_k else ""), fontsize=8); a.set_ylim(-0.05, 1.08); a.set_xlabel("x [um]"); a.grid(alpha=0.3)
    if k == 0:
        a.set_ylabel("density")
a = fig.add_subplot(gs[1, 5])
a.step(x_grid, x_baseline, where="mid", color="tab:gray", lw=1.2, label="baseline"); a.step(x_grid, x_optimized, where="mid", color="tab:blue", lw=1.2, label="optimized")
a.fill_between(x_grid, 0, x_optimized, step="mid", color="tab:blue", alpha=0.3); a.set_ylim(-0.05, 1.08); a.set_xlabel("x [um]"); a.set_title(f"final vs baseline ({gray} gray px)", fontsize=8); a.legend(fontsize=7); a.grid(alpha=0.3)
fig.suptitle("top: one manual gradient step (alpha sweep) and the MMA history; bottom: the design at every MMA evaluation", fontsize=10)
fig.tight_layout(); fig.savefig(os.path.join(OUT, "05_step_mma.png"), dpi=150); plt.close(fig)


# ---------------------------------------------------------------- contract 4: verification in a fresh simulation
def forward_orders(weights):
    s = mp.Simulation(geometry=geometry_with(weights), eps_averaging=False, **common)
    mon = s.add_mode_monitor(fcen, 0, 1, mp.ModeRegion(center=mp.Vector3(0, MON_Y), size=mp.Vector3(LAMBDA, 0)))
    dft = s.add_dft_fields([mp.Ez], fcen, 0, 1, center=mp.Vector3(), size=mp.Vector3(LAMBDA, SY))
    s.run(until_after_sources=stop_cond)
    total = float(mp.get_fluxes(mon)[0] / input_flux)
    eff = {m: float(abs(s.get_eigenmode_coefficients(mon, mp.DiffractedPlanewave((m, 0, 0), mp.Vector3(1, 0, 0), 1, 0)).alpha[0, 0, 0]) ** 2 / input_flux) for m in (-1, 0, 1)}
    field = s.get_dft_array(dft, mp.Ez, 0); eps = s.get_epsilon(); s.reset_meep()
    return eff, total, field, eps


report = {}
for tag, weights in (("baseline", x_baseline), ("optimized", x_optimized)):
    eff, total, fld, eps = forward_orders(weights)
    report[tag] = {"orders": eff, "sum": sum(eff.values()), "T_total": total, "field": fld, "eps": eps}
    print(f"verify [{tag}]: m=-1 {eff[-1]:.4f}, m=0 {eff[0]:.4f}, m=+1 {eff[1]:.4f}; sum {sum(eff.values()):.4f} = total {total:.4f}; "
          f"+1 / bound = {eff[1] / BLAZED_BOUND * 100:.1f} %")
fig, ax = plt.subplots(1, 3, figsize=(13, 4.4), gridspec_kw={"width_ratios": [1.4, 1, 1]})
ms = (-1, 0, 1); idx = np.arange(3)
ax[0].bar(idx - 0.2, [report["baseline"]["orders"][m] for m in ms], width=0.4, color="tab:gray", label="baseline (post-07 library)")
ax[0].bar(idx + 0.2, [report["optimized"]["orders"][m] for m in ms], width=0.4, color="tab:blue", label=f"after MMA (eval {best_k + 1})")
ax[0].axhline(BLAZED_BOUND, ls="--", color="crimson", lw=1.2, label=f"4-level blazed bound {BLAZED_BOUND:.3f}")
for k, m in enumerate(ms):
    ax[0].text(k - 0.2, report["baseline"]["orders"][m] + 0.008, f"{report['baseline']['orders'][m]:.3f}", ha="center", fontsize=8)
    ax[0].text(k + 0.2, report["optimized"]["orders"][m] + 0.008, f"{report['optimized']['orders'][m]:.3f}", ha="center", fontsize=8)
ax[0].set_xticks(idx); ax[0].set_xticklabels([f"m = {m:+d}" for m in ms]); ax[0].set_ylim(0, 1.0); ax[0].set_ylabel("efficiency (fresh forward run)")
ax[0].set_title("contract 4: measured again in a new simulation", fontsize=9); ax[0].grid(axis="y", alpha=0.3); ax[0].legend(fontsize=7)
lim = max(np.max(np.abs(report["baseline"]["field"])), np.max(np.abs(report["optimized"]["field"])))
for a, tag in zip(ax[1:], ("baseline", "optimized")):
    fld, eps = report[tag]["field"], report[tag]["eps"]
    a.imshow(np.real(fld).T, extent=EXTENT, origin="lower", cmap="RdBu", vmin=-lim, vmax=lim, aspect="equal")
    a.contour(xs, ys, eps.T, levels=[1.5, 6.0], colors="w", linewidths=0.6); a.set_title(f"Re(Ez), {tag}", fontsize=9); a.set_xlabel("x [um]")
ax[1].set_ylabel("y [um]")
fig.tight_layout(); fig.savefig(os.path.join(OUT, "06_verify.png"), dpi=150); plt.close(fig)

# ---------------------------------------------------------------- GIF: optimized pattern repeated 5 times, short pulse
periods = 5
fw_anim = 0.4 * fcen
aperture = periods * LAMBDA
sx_a = aperture + 2 * 1.0 + 2 * DPML
sy_a = DPML + DSUB + H + 2.5 + DPML
yb = -0.5 * sy_a
ydev = yb + DPML + DSUB
geom_a = [mp.Block(center=mp.Vector3(0, yb + 0.5 * (DPML + DSUB)), size=mp.Vector3(mp.inf, DPML + DSUB), material=SiO2)]
for j in range(periods):
    xj = -0.5 * aperture + (j + 0.5) * LAMBDA
    geom_a.append(mp.Block(center=mp.Vector3(xj, ydev + 0.5 * H), size=mp.Vector3(LAMBDA, H),
                           material=mp.MaterialGrid(mp.Vector3(Nx, Ny), mp.air, Si, weights=x_optimized.reshape(Nx, Ny), grid_type="U_MEAN", do_averaging=False)))
sim_a = mp.Simulation(resolution=RES, cell_size=mp.Vector3(sx_a, sy_a), boundary_layers=[mp.PML(DPML)], geometry=geom_a, eps_averaging=False,
                      sources=[mp.Source(mp.GaussianSource(fcen, fwidth=fw_anim, is_integrated=True), component=mp.Ez,
                                         center=mp.Vector3(0, yb + DPML + 0.3), size=mp.Vector3(aperture, 0))])
sim_a.init_sim()
vol_a = mp.Volume(center=mp.Vector3(), size=mp.Vector3(sx_a - 2 * DPML, sy_a - 2 * DPML))
eps_a = sim_a.get_array(vol=vol_a, component=mp.Dielectric)
ext_a = [-(sx_a / 2 - DPML), sx_a / 2 - DPML, -(sy_a / 2 - DPML), sy_a / 2 - DPML]
t_src = 5 / fw_anim
frames, times = record_frames(sim_a, vol_a, mp.Ez, t_start=t_src - 1 / fw_anim, t_end=t_src + 1.2 * sy_a * 1.45, n_frames=60)
animate_fields(frames, times, ext_a, os.path.join(OUT, "07_anim_optimized.gif"), eps=eps_a, figsize=(6.4, 4.6), dpi=70,
               title=f"optimized metagrating x{periods}: wavefront toward +{THETA_D:.0f} deg", legend_loc="lower right")

if mp.am_master():
    with open(os.path.join(OUT, "result.json"), "w") as f:
        json.dump({"params": {"wl": wl, "Lambda": LAMBDA, "H": H, "theta_d": THETA_D, "Nx": Nx, "w_lib": W_LIB.tolist()},
                   "input_flux": input_flux, "phase_spread": phase_spread,
                   "fom": {"baseline": f_baseline, "random": f_random, "gate_point": f_gate},
                   "gate": gate_rows, "gate_pass": gradient_gate,
                   "one_step": [{"alpha": a, "fom": f} for a, _, f in one_step],
                   "mma": {"history": history, "best_eval": best_k + 1, "gray_pixels": gray},
                   "verify": {k: {"orders": v["orders"], "sum": v["sum"], "T_total": v["T_total"]} for k, v in report.items()},
                   "blazed_bound": BLAZED_BOUND, "x_baseline": x_baseline.tolist(), "x_optimized": x_optimized.tolist(),
                   "wall_s_total": time.time() - t_all, "meep": mp.__version__, "nlopt": f"{nlopt.version_major()}.{nlopt.version_minor()}"}, f, indent=2)
원본 실행 기록과 재현 환경

§4의 발췌 코드와 달리 전체 코드에는 그림 저장·GIF 녹화·result.json 기록이 들어 있다. 그림 helper blogfig.py는 시리즈 공통이며 같은 폴더(code/)에 있다. 전체 코드와 helper: https://github.com/jin-castle/meep-examples/blob/main/code.

실행 결과 (2026-10-23 실행):

source check: input_flux = 1.86866e+01, phase spread across x at mid-height = 0.0000 rad (normal incidence)
forward: baseline +1 efficiency = 0.4970 (|grad| = 6.037e-01); random grayscale start = 0.0177; adjoint sources: 1 x EigenModeSource
gradient: largest 5 |dJ/drho| at x = -0.275 (+0.157, rho=0), -0.250 (+0.208, rho=1), -0.225 (+0.232, rho=1), -0.200 (+0.215, rho=1), -0.175 (+0.165, rho=0)
gate: interior-point FOM = 0.4871; step 2e-03: FD 5.4104e-01 vs adjoint 5.4472e-01, rel 0.0068 PASS; step 5e-03: FD 5.4538e-01 vs adjoint 5.4472e-01, rel 0.0012 PASS; step 1e-02: FD 5.4505e-01 vs adjoint 5.4472e-01, rel 0.0006 PASS -> gradient gate PASS
one manual step: alpha 0.05 -> 0.5075 (+0.0105), alpha 0.3 -> 0.5549 (+0.0579), alpha 0.8 -> 0.6134 (+0.1163), alpha 2.0 -> 0.4840 (-0.0130)
MMA (maxeval 5): eval 1: 0.4970, eval 2: 0.5248, eval 3: 0.6241, eval 4: 0.0492, eval 5: 0.5398; best eval 3 = 0.6241 (1.256x); grayscale pixels 27/73
verify [baseline]: m=-1 0.1026, m=0 0.0666, m=+1 0.4959; sum 0.6651 = total 0.6651; +1 / bound = 61.2 %
verify [optimized]: m=-1 0.0973, m=0 0.0169, m=+1 0.6228; sum 0.7369 = total 0.7369; +1 / bound = 76.8 %

재현 환경: meep 1.33.0 · nlopt 2.x · autograd · Python 3.11 · conda install -c conda-forge pymeep nlopt autograd · 실행 python metagrating_inverse.py (약 48 s, 단일 코어)

공식 문서와 다음 글

]]>jin-castleMeep Example 12 · 빛을 가두는 고리 — Harminv, Q, FSR, solve_cw 교차검증2026-10-23T00:00:00+00:002026-10-23T00:00:00+00:00https://jin-castle.github.io/meep-examples/ring-resonator1. 먼저 관찰하기

고리에 짧은 펄스를 넣었다가 끄면 빛은 바로 사라질까요? 아래 영상에서 고리를 도는 울림과 바깥으로 새는 빛을 찾아보세요. 11편의 두 거울 대신, 이번에는 유전체 도파로를 둥글게 말아 빛을 가둡니다.

광대역 펄스 뒤 고리에서 울리는 전기장과 바깥으로 새는 빛
펄스가 꺼진 뒤에도 세 모드가 함께 울려 맥놀이가 보입니다. 낮은 모드부터 PML 쪽으로 새어 나갑니다.

이번 질문: 어떤 주파수의 빛이 남고, 얼마나 오래 남으며, 그 답을 어떻게 검증할까요? 아래 측정은 2D Ez·손실 없는 고립 고리의 결과입니다. 도파로와의 결합 손실이나 3D 소자의 Q를 포함하지 않습니다.

English summary
  • What: post 11 measured how much a dipole emits between two mirrors. On a chip the trap is a dielectric ring. This post asks the first questions about any resonator: at which frequencies does it trap light, for how long (Q), how far apart are the resonances (FSR), and what does each trapped mode look like. Official ring.py (Harminv on the ringing field), one narrow-band run per mode, and official solve-cw.py (the same mode solved in the frequency domain).
  • Result: a broadband pulse in the band 0.10–0.20 excites three Ez modes; at the official resolution 10 Harminv gives f = 0.1181 / 0.1472 / 0.1753 with Q = 81 / 317 / 1675 (tutorial: 0.1181 / 0.1472 / 0.1752, Q 81 / 316 / 1677). The frequencies move by less than 0.3% between resolution 10 and 30; the Q of the sharpest mode goes 1675 → 2132 → 1610, not monotonically. The spacing 0.0292 / 0.0283 matches 1/(n_g L) with n_g = 3.69, and the three modes carry m = 3, 4, 5 wavelengths around the ring. solve_cw reproduces the time-domain DFT of the f = 0.118 mode to 0.40% relative L2 ( Ez correlation 0.99998) after a complex scale factor.
  • Takeaway: Harminv turns 300 time units of ringing into frequencies and Q without waiting for the field to decay, but Q converges much more slowly with resolution than the frequency does. One mode at a time needs a source as narrow as the mode. The frequency-domain solver and the time-domain pulse are two routes to the same steady state, and agreeing to a percent is what “the same mode” means.
  • Code: full script at the bottom, ~4 min (mpirun -np 4).
공진기는 어디에 쓰일까요?

11편의 금속 상자는 구멍 하나로 Q를 조절했다. 칩 위에서는 금속 상자를 쓰지 않는다. 유전체 도파로를 고리로 말면 빛이 전반사로 돌면서 갇히고, 05편에서 본 굽힘 방사가 유일한 손실이 된다. 이 고리에 펄스를 넣으면 어떤 주파수가 남는가, 얼마나 오래 남는가, 남은 주파수들은 얼마나 떨어져 있는가. 그리고 그 답을 어떻게 재는가. 시간영역에서 울림을 분해하는 Harminv와, 주파수 영역에서 정상상태를 직접 푸는 solve_cw 두 가지로 재고 서로 맞는지 본다.

어디에 쓰이는가

고리 공진기는 실리콘 포토닉스에서 가장 많이 쓰는 부품이다. 공진 주파수, Q, FSR 세 숫자가 그대로 소자 사양이 된다.

| 응용 | 이 글의 어떤 것을 쓰는가 | 그 다음에 필요한 것 | |—|—|—| | 파장 필터, add-drop 다중화기(WDM), ring 변조기 | 공진 주파수와 FSR(채널 간격), Q(선폭 = 통과 대역) | 30편 GDS ring | | 바이오·가스 센서 | 공진 이동 Δf를 선폭 f/Q로 나눈 것이 검출 한계 | 13편 디스크 공진기 | | microring·microdisk 레이저, 주파수 빗(comb) | Q와 모드 부피(threshold), FSR(빗 간격) | 22편 비선형 | | 모든 공진 구조의 측정 절차 | Harminv로 f·Q, 좁은 대역으로 모드 하나, solve_cw로 정상상태 | 26편 photonic crystal cavity |

2. 결과를 예측해 보기

해상도를 10 → 20 → 30으로 높이면 주파수와 Q가 함께 매끄럽게 수렴할까요? 먼저 골라보세요.

해상도를 높였을 때 두 숫자의 수렴을 예상해 보세요.
예측 확인하기

두 번째입니다. 세 번째 모드의 주파수는 0.17525 → 0.17564 → 0.17572지만, Q는 1675 → 2132 → 1610입니다. Q는 작은 방사 손실을 재므로 경계를 격자로 표현하는 방식에 더 민감합니다. 뒤에서 이 차이를 실제 표로 확인합니다.

3. 원리 이해하기

고리 공진의 원리 고리를 한 바퀴 돈 파동이 같은 위상으로 만나면 보강됩니다. 바깥으로 새는 빛이 울림의 수명을 제한합니다. 한 바퀴 뒤 위상이 맞으면 보강 방사 손실 둘레 L에 파장이 m개 들어가는 공진
원리 개념도입니다. 점선은 빛의 왕복 경로를, 화살표는 진행과 누설을 뜻합니다. 실제 전기장 분포나 손실 크기를 그린 그림은 아닙니다.

고리를 한 바퀴 돌아온 파동이 같은 위상으로 만나면 보강됩니다. 그래서 아무 주파수나 남는 것이 아니라, 둘레에 맞는 공진 주파수만 남습니다. Q는 그 울림이 얼마나 천천히 사라지는지, FSR은 이웃한 공진 주파수가 얼마나 떨어져 있는지를 말합니다.

Harminv는 source가 꺼진 뒤 한 점에 남는 신호에서 주파수와 감쇠율을 함께 찾습니다. Q가 크다고 감쇠가 끝날 때까지 기다릴 필요는 없지만, 추정 오차를 확인해야 합니다. 양의 Q·관측 대역 안의 모드와 error < f/(2Q)가 기본 조건이며, 이 글의 세 모드는 error가 그 기준의 2% 아래입니다.

공진 식·기호와 정량 예측 자세히 보기

고리를 한 바퀴 돈 빛의 위상이 자기 자신과 맞을 때만 보강된다. 둘레 $L=2\pi R_{\mathrm{mid}}$에 파장이 정수 $m$개 들어가는 조건이 공진이고, 이웃한 $m$ 사이의 주파수 간격이 FSR이다. 군굴절률 $n_g$는 분산을 포함한 값이라 재료 굴절률과 다르다. 손실이 굽힘 방사뿐이면 주파수가 높을수록 빛이 고리 안쪽에 더 단단히 갇혀 Q가 커진다.

\[m\,\lambda_m = n_{\mathrm{eff}}L,\qquad \mathrm{FSR}=f_{m+1}-f_m\approx\frac{1}{n_g L},\qquad Q=\frac{f}{\Delta f}=\frac{\mathrm{Re}\,\omega}{-2\,\mathrm{Im}\,\omega}\]

Harminv는 source가 꺼진 뒤 한 점에서 기록한 field를 감쇠 사인파의 합 $\sum_k a_k e^{-i\omega_k t}$로 분해한다. 복소 $\omega_k$의 실수부가 공진 주파수, 허수부가 감쇠율이고 둘의 비가 Q다. 수명이 수천 time unit인 모드도 300 time unit의 기록으로 잡히지만, 각 모드에 붙는 error가 허수부보다 작아야 그 Q를 믿을 수 있다.

주파수 영역 solver는 같은 문제를 다르게 푼다. 연속파 source를 켜고 $\nabla\times\nabla\times\mathbf E-\omega^2\varepsilon\mathbf E=i\omega\mathbf J$를 반복법(BiCGSTAB-L)으로 풀어 정상상태를 바로 얻는다. 시간영역의 펄스 + DFT와 같은 모드를 주어야 하지만 source 정규화와 전체 위상이 다르므로 복소 상수 하나를 맞춘 뒤 비교한다.

기호 뜻 코드 변수
$R$, $w$, $n$ 안쪽 반지름 1, 폭 1, 굴절률 3.4 (단위 a = 1 µm) R, W, N_RING
$L$ 평균 둘레 $2\pi(R+w/2)$ = 9.42 L_RING
$f_{\mathrm{cen}}$, $df$ 광대역 펄스 0.15 ± 0.05 FCEN, DF
$m$ 방위 차수(둘레의 파장 수) m_az
$Q$, error Harminv 출력 h.modes[k].Q, .err
tol solve_cw 반복 종료 기준 TOLS
$\alpha$ CW와 DFT를 맞추는 복소 상수 alpha

가정과 유효 범위: 2D Ez, 손실 없는 유전체, 단위 a = 1 µm(공진 파장 5.7~8.5 µm). 통신 파장으로 옮기려면 모든 길이에 0.27을 곱한다. 고리가 도파로와 결합하지 않은 고립 고리라 Q는 굽힘 방사만 반영한다.

결과 보기 전에 맞춰보기

물리량 내 예측 근거
대역 0.10~0.20의 모드 수 3 FSR ≈ 1/(3.5 × 9.42) ≈ 0.03, 대역 0.1
공진 주파수 (res 10) 0.118 / 0.147 / 0.175 공식 튜토리얼
Q의 경향 고주파일수록 크다 굽힘 방사는 느슨한 구속에서 크다
res 10 → 30의 주파수 변화 1% 안 파장당 20칸 이상
res 10 → 30의 최고 Q 변화 수십 % 노트: res 25에서 2515, 공식 res 10은 1677
방위 차수 m 연속 정수 세 개, 3~6 사이 $m\approx n_{\mathrm{eff}}Lf$, $n_{\mathrm{eff}}<3.4$
solve_cw 오차 tolerance를 조이면 단조 감소 튜토리얼
CW vs 시간영역 DFT L2 2% 안, 상관 0.999 이상 노트 1.2%, 0.99992

판정 기준: FSR이 손계산과 30% 넘게 다르면 둘레나 굴절률을 의심한다. Harminv error가 허수부보다 크면 그 Q는 보고하지 않는다. CW와 DFT가 10% 넘게 다르면 source 대칭이나 주파수가 어긋난 것이다.

4. 변수 하나 바꿔 실험하기

이번에는 Harminv가 울림을 관측하는 시간만 바꿉니다. 저장소의 code/ 폴더에서 공통 helper blogfig.py와 ring_resonator.py를 함께 두고 Meep 환경에서 실행하세요. 전체 코드는 아래 참고 자료에도 있습니다. 단일 CPU 기준 약 10분이며, 원문의 4분은 4개 MPI 프로세스를 사용한 기록입니다.

OMP_NUM_THREADS=1 python ring_resonator.py
  1. 원본의 T_HARMINV = 300.0으로 실행해 각 모드의 f·Q·error를 기록합니다.
  2. 이 값만 600.0으로 바꾸고 다시 실행합니다. 구조·해상도·source는 고정합니다.
  3. 같은 주파수의 모드를 짝지어 error와 f/(2Q)를 비교합니다. 관측 시간을 늘리는 실험과 공간 해상도를 높이는 실험은 서로 다른 오차를 확인합니다.

판단 기준: 관측 시간을 늘린 뒤 주파수와 Q가 얼마나 움직였는지 직접 기록하세요. 시간이 길어졌다는 이유만으로 Q가 정확하다고 결론 내릴 수는 없습니다. 아래 수치는 원본의 300 time unit 결과이며, 600의 새 측정값은 아닙니다.

시뮬레이션 배치와 파라미터 확인하기
고리와 source·Harminv probe·PML의 배치
16 × 16 셀(a = 1 µm), PML 2. 고리는 n = 3.4, 안쪽 반지름 1, 폭 1입니다. 빨간 점은 Ez 점원이자 Harminv probe(r + 0.1, 0)이며 flux monitor는 없습니다. 원의 번호는 아래 코드의 단계입니다.
파라미터 값 왜 이 값인가 바꾸면
고리 n 3.4, R 1, w 1 공식 ring.py 둘레가 바뀌면 FSR이 바뀐다
펄스 fcen 0.15, df 0.1 대역 0.10~0.20에 모드 셋 대역이 좁으면 모드를 놓친다
source 위치 (R + 0.1, 0) 대칭축에서 비켜 모든 Ez 모드를 여기 축 위에 두면 odd 모드가 빠진다
Harminv 창 source 종료 후 300 공식 값. Q 수천까지 분해 너무 짧으면 error가 커진다
해상도 10 (공식), 20, 30 수렴성 Q가 해상도에 민감(§5)
모드 영상 df 0.01, DFT at f_k 이웃 모드(0.03 떨어짐)를 배제 df 0.1이면 세 모드가 겹친 그림
solve_cw f 0.118, tol 1e-8/1e-10/1e-12, maxiters 10000, L 10 공식 solve-cw.py L을 기본 2로 두면 수렴이 느리다
CW source 대칭 (±(R+0.1), 0)에 진폭 +1/−1, X odd 0.118 모드의 parity parity가 틀리면 다른 모드를 푼다
광대역 Gaussian 펄스의 시간 파형과 스펙트럼
광대역 펄스의 파형과 스펙트럼(a 단위). 폭 10, 정점 t0 = 50. 300 time unit의 Harminv 창은 source가 꺼진 뒤 시작합니다.

강의 노트북과의 차이: 강의 범위 밖이다. 10_sources의 0710 노트는 res 25 한 점, 0722 노트는 solve_cw tolerance 5점이었다. 이 글은 해상도 세 점(10/20/30)으로 주파수와 Q의 수렴 속도 차이를 보이고, 모드마다 좁은 대역으로 다시 돌려 방위 차수 m을 센다.

코드를 일곱 단계로 따라가기

읽는 순서: 단위·파라미터 → 재료·구조 → source → Simulation·경계 → monitor → 실행·종료 → 후처리. 이번 글의 ⑤는 flux monitor가 아니라 Harminv(한 점의 시간 신호)와 solve_cw다.

① 단위와 파라미터 — 어떤 숫자를 고정하는가

N_RING, W, R = 3.4, 1.0, 1.0                # index, ring width, inner radius  [a = 1 um]
PAD, DPML = 4.0, 2.0
SXY = 2 * (R + W + PAD + DPML)              # 16 x 16
FCEN, DF = 0.15, 0.1                        # broadband pulse covering 0.10..0.20
T_HARMINV = 300.0                           # ringing window after the source (official)
L_RING = 2 * np.pi * (R + 0.5 * W)          # mean circumference, for the FSR estimate
  • 무엇: 공식 값 그대로. 둘레 $L$은 FSR 손계산용.
  • 왜: 실행 전에 $1/(n_g L)$로 모드 수를 어림해 두면 Harminv가 모드를 빠뜨렸는지 바로 안다.
  • 틀리면: PML이 고리에 가까우면(pad 작게) 방사장이 흡수되기 전에 되돌아와 Q가 틀어진다.

② 재료와 구조 — 두 원기둥으로 고리

geometry = [mp.Cylinder(radius=R + W, material=mp.Medium(index=N_RING)),     # later objects win: outer dielectric first ...
            mp.Cylinder(radius=R)]                                             # ... then the air hole
  • 무엇: 유전체 원기둥 위에 공기 원기둥을 덮어 고리를 만든다.
  • 왜: Meep은 나중 객체가 앞 객체를 덮어쓴다. 순서가 반대면 유전체 원판이 된다.
  • 틀리면: 11편의 금속 상자도 같은 규칙(금속 → 공기 → 구멍)이었다.

③ Source — 광대역 하나, 좁은 대역 셋, 연속파 둘

mp.Source(mp.GaussianSource(FCEN, fwidth=DF), mp.Ez, SRC_PT)                    # A: broadband, every mode in the band
mp.Source(mp.GaussianSource(f0, fwidth=0.01), mp.Ez, SRC_PT)                    # B: one mode at a time
[mp.Source(mp.ContinuousSource(F_CW), mp.Ez, mp.Vector3(R + 0.1)),             # C: continuous wave, antisymmetric pair
 mp.Source(mp.ContinuousSource(F_CW), mp.Ez, mp.Vector3(-(R + 0.1)), amplitude=-1)]
  • 무엇: 목적에 따라 세 가지 source. A는 모든 모드를 한 번에, B는 하나씩, C는 정상상태.
  • 왜: 모드 하나를 보려면 이웃 모드(0.03 떨어짐)가 들어오지 않는 대역(0.01)이 필요하다. Harminv의 중심 주파수를 바꾸는 것만으로는 source 스펙트럼이 바뀌지 않는다. 공식 예제 하나(ring-mode-overlap.py)가 바로 그 실수를 하고 Meep이 경고를 낸다.
  • 틀리면: 연속파 source 둘의 부호가 같으면 X-even 모드를 풀게 되어 시간영역의 0.118 모드와 맞지 않는다.

④ Simulation과 경계 — 대칭과 복소 field

sim = mp.Simulation(cell_size=mp.Vector3(SXY, SXY), geometry=geometry, sources=sources, resolution=res,
                    symmetries=[mp.Mirror(mp.Y)], boundary_layers=[mp.PML(DPML)])                                   # A, B
sim = make_sim(RES_IMG, src_cw, (mp.Mirror(mp.X, phase=-1), mp.Mirror(mp.Y, phase=+1)), force_complex_fields=True)  # C
  • 무엇: 사방 PML 2. A·B는 Y 거울 대칭(source가 x축 위), C는 X odd + Y even과 복소 field.
  • 왜: solve_cw는 정상상태의 진폭과 위상을 함께 주므로 복소 field가 필요하다. 대칭은 계산을 1/2, 1/4로 줄이고 모드의 parity를 고른다.
  • 틀리면: 11편과 같은 규칙. 위상을 전부 +1로 두면 다른 parity의 모드를 푼다.

⑤ Monitor — Harminv와 DFT, 그리고 solve_cw

h = mp.Harminv(mp.Ez, SRC_PT, FCEN, DF)                   # A: time signal at one point -> (f, Q, amp, err) per mode
sim.run(mp.after_sources(h), until_after_sources=T_HARMINV)
modes = [(m.freq, m.Q, abs(m.amp), m.err) for m in h.modes if m.Q > 0]

dft = sim.add_dft_fields([mp.Ez], f0, 0, 1, where=NONPML)  # B: steady-state field at the resonance

sim.init_sim(); sim.solve_cw(tol, MAXITERS, L_BICG)        # C: frequency-domain solve, then read the field
ez_cw = sim.get_array(vol=NONPML, component=mp.Ez)
  • 무엇: Harminv는 한 점의 시간 신호를 받는 step function이다. after_sources로 source가 꺼진 뒤부터 기록한다. B의 DFT는 공진 주파수 하나의 정상상태. C는 solve 뒤 get_array로 field를 읽는다.
  • 왜: 공진의 세 숫자는 한 점의 시간 신호에 다 들어 있다. 공간 monitor는 모드의 모양을 볼 때만 필요하다.
  • 틀리면: Harminv probe를 모드의 마디(node)에 두면 그 모드가 안 보인다. source와 같은 점을 쓰면 적어도 여기된 모드는 보인다.

⑥ 실행 — 울림 창, 감쇠 조건, 반복 종료

sim.run(mp.after_sources(h), until_after_sources=300)                                              # A: fixed window (official)
sim.run(until_after_sources=mp.stop_when_fields_decayed(50, mp.Ez, SRC_PT, 1e-6))                  # B
sim.solve_cw(tol, 10000, 10)                                                                        # C
sim.run(until_after_sources=mp.stop_when_fields_decayed(50, mp.Ez, mp.Vector3(R + 0.1523), 1e-8))   # C, time-domain comparator
  • 무엇: A는 고정 창(공식). B와 C의 시간영역은 감쇠 조건. C의 solve는 tolerance와 최대 반복.
  • 왜: Harminv는 감쇠가 끝나기를 기다리지 않는다. 그것이 Harminv의 존재 이유다. 반대로 DFT는 field가 다 빠져야 정확하므로 Q가 큰 모드일수록 오래 돈다(11편의 2Q/f).
  • 틀리면: B에서 감쇠 기준을 느슨하게 하면 DFT에 꼬리가 남아 모드 모양에 이웃 모드가 섞인다.

⑦ 후처리 — FSR, m, 복소 정렬

fsr = np.diff(freqs); ng = 1 / (fsr.mean() * L_RING)                      # group index from the spacing
ring_vals = ez[ix, iy]                                                     # DFT field sampled on the mid-circle
m_az = int(np.argmax(np.abs(np.fft.rfft(np.real(ring_vals)))[1:]) + 1)   # dominant azimuthal order

alpha = np.vdot(ez_td, ref) / np.vdot(ez_td, ez_td)                        # best-fit complex scale
err_td = np.linalg.norm(alpha * ez_td - ref) / np.linalg.norm(ref)
  • 무엇: 공진 간격에서 $n_g$를 역산하고, 고리 가운데 원 위의 field를 Fourier 변환해 $m$을 세고, CW와 DFT를 복소 상수로 맞춘 뒤 L2를 잰다.
  • 왜: source 정규화(연속파 vs 펄스의 DFT)와 전체 위상은 물리가 아니다. 그것을 빼고 남는 차이가 solver의 차이다.
  • 틀리면: $\alpha$ 없이 비교하면 L2가 100%를 넘고, 위상만 다른 같은 모드를 다른 모드로 읽는다.

함정: Harminv가 돌려주는 모드에는 Q가 음수이거나 error가 큰 가짜가 섞인다. Q > 0이고 대역 안에 있는 것만 남기고, error를 허수부 $f/(2Q)$와 비교한다. 이 글의 세 모드는 모두 error가 허수부의 2% 아래다.

5. 결과를 해석하기

먼저 세 번째 모드의 주파수와 Q를 나란히 읽어보세요. 해상도 10 → 30에서 주파수 변화는 0.3% 이하지만 Q는 비단조로 움직입니다. 따라서 주파수는 안정적이어도 Q의 절대값은 아직 수렴했다고 주장할 수 없습니다.

해상도별 공진 주파수·Q와 FSR 비교
왼쪽의 주파수는 거의 움직이지 않지만 Q는 크게 바뀝니다. 오른쪽은 공진 간격 FSR과 손계산, 각 모드의 방위 차수 m입니다. 그림을 누르면 확대할 수 있습니다.
res $f_1$ / $Q_1$ $f_2$ / $Q_2$ $f_3$ / $Q_3$
10 (공식) 0.11810 / 81 0.14716 / 317 0.17525 / 1675
20 0.11818 / 79 0.14736 / 342 0.17564 / 2132
30 0.11822 / 79 0.14740 / 336 0.17572 / 1610
측정 FSR $n_g = 1/(\mathrm{FSR}\,L)$ 고리 굴절률
0.0292 / 0.0283 3.69 3.4

FSR이 말하는 것: 간격 0.0292 / 0.0283에서 군굴절률 3.69를 얻습니다. 이는 재료 굴절률 3.4와 같은 양이 아닙니다. 아래 모드는 둘레에 각각 m = 3, 4, 5개의 파장이 들어갑니다.

모드 모양과 주파수 영역 교차검증 보기
세 공진 모드의 전기장과 둘레 방향 진동 횟수
위는 각 주파수의 좁은 대역 DFT입니다. 아래는 r = 1.5인 원 위의 Re(Ez)이며, 둘레에 파장이 m개 들어갑니다.
모드 f λ [a] Q (res 20) m $m/(n L f)$
1 0.1182 8.46 79 3 0.79
2 0.1474 6.79 342 4 0.85
3 0.1756 5.69 2132 5 0.89
solve_cw tolerance 비교와 시간영역 DFT의 전기장 비교
왼쪽은 tolerance별 오차입니다. 가운데 주파수 영역 해와 오른쪽 시간영역 DFT는 복소 상수로 정규화와 전체 위상을 맞춘 뒤 비교합니다.
항목 값
solve_cw tol 1e-8 / 1e-10 / 1e-12 소요 5 / 6 / 7 s (4 프로세스)
tol 1e-8, 1e-10의 상대오차 (vs 1e-12) 4.2e-7, 1.1e-10
시간영역 DFT vs CW, 복소 정렬 후 L2 0.40%
|Ez| 상관 0.99998
시간영역 run 길이 (감쇠 1e-8) 2001 time unit

두 해법의 확인: f = 0.118 모드에서 solve_cw와 시간영역 DFT는 복소 정렬 후 상대 L2 0.40%, 진폭 상관 0.99998로 일치합니다. 이 확인이 모든 모드의 Q 수렴까지 보장하지는 않습니다.

원래의 여덟 예측·수렴성·해석 자세히 보기

예측과 비교

물리량 내 예측 (§2) 시뮬레이션 판정
모드 수 3 3 ✅
공진 주파수 (res 10) 0.118 / 0.147 / 0.175 0.1181 / 0.1472 / 0.1753 ✅
Q 경향 고주파일수록 크다 81 → 317 → 1675 ✅
res 10→30 주파수 변화 1% 안 0.3% 이하 ✅
res 10→30 최고 Q 변화 수십 % 1675 → 2132 → 1610 (비단조, ±30%) ✅ (단조는 아님)
방위 차수 m 연속 정수, 3~6 3, 4, 5 ✅
solve_cw 오차 단조 감소 4.2e-7, 1.1e-10 ✅
CW vs DFT L2 2% 안, 상관 0.999 이상 0.40%, 0.99998 ✅

여덟 예측이 모두 방향은 맞았고, 숫자에서 두 가지를 배웠다. 첫째, Q의 해상도 의존은 단조가 아니다. 가장 날카로운 모드의 Q가 res 10에서 1675, 20에서 2132, 30에서 1610이다. 굽힘 방사는 고리 바깥 경계의 작은 누설이고, 그 누설이 격자가 경계를 어떻게 자르느냐(staircase)에 따라 달라지므로 해상도를 올려도 한 방향으로 수렴하지 않는다. 주파수는 세 해상도에서 0.3% 안이다. 둘째, $m/(n L f)$가 0.79, 0.85, 0.89로 1보다 작고 주파수가 높을수록 1에 가깝다. 모드가 고리 밖으로 새어 있어 유효 굴절률이 3.4보다 작고, 높은 모드일수록 안쪽에 갇혀 유효 굴절률이 재료값에 다가간다는 뜻이다. FSR에서 역산한 $n_g$ 3.69가 재료 굴절률보다 큰 것은 분산($n_g = n_{\mathrm{eff}} + f\,dn_{\mathrm{eff}}/df$)이고, 같은 현상의 다른 면이다. 모드 하나를 보는 run은 Q에 비례해 길어진다. Q 2132 모드는 감쇠 1e-6까지 19110 time unit이 걸렸다. Harminv가 300으로 끝내는 일을 DFT는 60배 긴 시간에 한다. solve_cw는 세 tolerance 모두 수 초였고, 시간영역 DFT와 0.4%에서 같다.

수렴성

변수 값 결과 비고
해상도 (Harminv) 10 / 20 / 30 $f_3$: 0.17525 / 0.17564 / 0.17572, $Q_3$: 1675 / 2132 / 1610 주파수는 20칸/파장에서 수렴, Q는 아직
Harminv 창 300 (공식) error ≤ 1e-5, 허수부 f/(2Q)의 2% 아래 창을 늘리면 error가 준다
solve_cw tolerance 1e-8 / 1e-10 / 1e-12 4.2e-7, 1.1e-10 노트: 1e-11 근처에서 비단조

주장할 수 있는 것 / 없는 것

  • 할 수 있는 것: 이 고리(2D, n 3.4, R 1, w 1)의 대역 0.10~0.20에는 Ez 모드가 셋 있고 주파수는 해상도 10에서 이미 1% 안이다. 간격은 $n_g$ 3.69의 $1/(n_gL)$과 같다. f = 0.118 모드는 시간영역과 주파수 영역이 0.40% 안에서 같다.
  • 할 수 없는 것: Q의 절대값. 해상도 30에서도 수렴하지 않았고 Harminv 창 300의 값이다. 도파로와 결합한 고리의 Q(결합 손실이 더해진다). 3D 디스크의 값. 통신 파장으로 축소했을 때의 재료 분산.
결과가 예상과 다를 때 확인할 것
증상 원인 고치는 법
Harminv가 모드를 하나만 줌 source 대역이 좁거나 probe가 마디 df를 넓히고 probe를 source 점에
Q가 수만, error도 큼 가짜 모드 Q > 0, error < f/(2Q), 대역 안만
모드 그림에 이웃 모드가 섞임 모드 영상 source 대역이 FSR보다 넓음 df < FSR/3
Harminv 중심만 바꿨는데 결과 그대로 source 스펙트럼은 안 바뀜 source를 새로 만든다(공식 ring-mode-overlap.py의 경고)
solve_cw가 수렴 안 함 L = 2, 복소 field 없음 L = 10, force_complex_fields=True
CW와 DFT가 100% 다름 정규화·위상 미정렬, 또는 parity 다름 복소 상수 α로 정렬, source 부호 확인
해상도를 올렸더니 Q가 크게 변함 정상. Q는 느리게 수렴 Q는 해상도 사다리와 함께 보고
추가 실험 아이디어
바꿀 것 예상 변화 확인할 수치
고리 폭 w 1 → 0.5 구속이 약해져 Q 감소, FSR 증가(둘레 ↓) f, Q, FSR
source를 y축 위 (0, R + 0.1)에 기존 Y 대칭과 호환되는지 먼저 확인 모드 수와 source 대칭
Harminv 창 300 → 1000 error 감소, Q 안정 error, Q
res 40 Q_3 수렴 여부 Q_3
ω–2ω 겹침 (ring-mode-overlap.py) 0.118과 0.236 모드의 공간 겹침 0.05 정규화 overlap

6. 이해했는지 확인하기

  1. 주파수가 0.3% 안에서 안정되었는데 Q가 1675 → 2132 → 1610이라면 무엇을 보고해야 할까요?
  2. Harminv 관측 시간을 늘리는 것과 해상도를 높이는 것은 같은 검증일까요?
답과 이유 확인하기
  1. 주파수는 안정적이지만 Q의 절대값은 아직 수렴하지 않았다고 보고합니다. 사용한 해상도·관측 시간·error를 함께 제시합니다.
  2. 다릅니다. 관측 시간은 시간 신호에서 모드를 추정하는 오차를, 해상도는 구조와 장을 공간 격자로 표현하는 오차를 확인합니다. 작은 Harminv error만으로 공간 수렴을 보장할 수 없습니다.

7. 코드와 참고자료

공식 예제: Basics 튜토리얼의 ring resonator · Frequency-domain solver 튜토리얼 · 스크립트 ring.py · solve-cw.py.

전체 코드

code/ring_resonator.py 전체 (클릭하여 펼치기) 
"""Meep Example 12 - A ring that traps light: Harminv resonances, Q, FSR, and a solve_cw cross-check.

Post 11 measured how much a dipole emits between two mirrors. On a chip the trap is a dielectric ring, and
the first questions about any resonator are: at which frequencies does it trap light, for how long (Q),
how far apart are the resonances (FSR), and what does each trapped mode look like.
  A. Official ring.py: a broadband Ez pulse inside the ring, Harminv on the ringing field after the source
     stops -> frequencies and Q of the modes in the band. Repeated at resolution 10 (official), 20, 30:
     frequencies converge fast, Q of the sharpest mode does not.
  B. Each resonance imaged alone: a narrow-band pulse at that frequency and a DFT field at the same frequency.
     The number of azimuthal lobes m is counted from the field along the ring.
  C. Official solve-cw.py: the same mode at f = 0.118 solved in the frequency domain (continuous source,
     BiCGSTAB-L), tolerance sweep, and compared with a time-domain DFT of the same mode after complex alignment.
Written to run under MPI: collective calls (run, get_array, solve_cw) on every rank, plotting on the master only.

Run:  python ring_resonator.py        (~10 min on one core, ~4 min with mpirun -np 4)
Out:  00_source.png, 01_layout.png, 02_harminv.png, 03_modes.png, 04_solve_cw.png, 05_anim_ring.gif, result.json
      (-> ../assets/12/)
"""
import json
import os
import sys
import time

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import meep as mp

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from blogfig import Label, animate_fields, annotated_layout, record_frames, source_figure   # noqa: E402

HERE = os.path.dirname(os.path.abspath(__file__))
OUT = os.path.join(HERE, "..", "assets", "12")
os.makedirs(OUT, exist_ok=True)
MASTER = mp.am_master()
t_all = time.time()


def say(*a):
    if MASTER:
        print(*a, flush=True)


# ---------------------------------------------------------------- (1) parameters (official ring.py; a = 1 um)
N_RING, W, R = 3.4, 1.0, 1.0                # index, ring width, inner radius  [a = 1 um]
PAD, DPML = 4.0, 2.0
SXY = 2 * (R + W + PAD + DPML)              # 16 x 16
FCEN, DF = 0.15, 0.1                        # broadband pulse covering 0.10..0.20
T_HARMINV = 300.0                           # ringing window after the source (official)
SRC_PT = mp.Vector3(R + 0.1)                # inside the ring, off the symmetry axes of the modes
RES_LIST = (10, 20, 30)                     # official 10, plus two finer
RES_IMG = 20                                # resolution for mode images, solve_cw, GIF
R_MID = R + 0.5 * W
L_RING = 2 * np.pi * R_MID                  # mean circumference
NONPML = mp.Volume(center=mp.Vector3(), size=mp.Vector3(SXY - 2 * DPML, SXY - 2 * DPML))
EXT = [-(0.5 * SXY - DPML), 0.5 * SXY - DPML, -(0.5 * SXY - DPML), 0.5 * SXY - DPML]

geometry = [mp.Cylinder(radius=R + W, material=mp.Medium(index=N_RING)),     # later objects win: outer dielectric first ...
            mp.Cylinder(radius=R)]                                             # ... then the air hole


def make_sim(res, sources, symmetries=(mp.Mirror(mp.Y),), **kw):
    return mp.Simulation(cell_size=mp.Vector3(SXY, SXY), geometry=geometry, sources=sources, resolution=res,
                         symmetries=list(symmetries), boundary_layers=[mp.PML(DPML)], **kw)


# ================================================================ A. Harminv at three resolutions
harm = {}
t_a = time.time()
for res in RES_LIST:
    src = [mp.Source(mp.GaussianSource(FCEN, fwidth=DF), mp.Ez, SRC_PT)]
    sim = make_sim(res, src)
    if res == RES_LIST[0]:
        annotated_layout(sim, os.path.join(OUT, "01_layout.png"), dpml=DPML, figsize=(6.6, 6.2), axis_step=2.0,
                         title="ring resonator (res 10 shown): n = 3.4, inner radius 1, width 1, a = 1 um",
                         params_text=f"n={N_RING}, r={R}, w={W}\nfcen={FCEN}, df={DF}\nres {RES_LIST}", params_xy=(-7.6, 7.0),
                         pml_xy=(-7.6, -6.6), decay_point=None,
                         labels=[Label("Ez point source at (r + 0.1, 0): every Ez mode in the band", (R + 0.1, 0.0), (-7.6, 4.6), step=3, color="red"),
                                 Label("ring = dielectric cylinder minus air cylinder", (-R_MID * 0.7, R_MID * 0.7), (-7.6, 3.2), step=2, color="black"),
                                 Label("Harminv probe = the source point, after the source", (R + 0.1, -0.3), (-5.2, -4.2), step=5, color="blue")])
    h = mp.Harminv(mp.Ez, SRC_PT, FCEN, DF)
    sim.run(mp.after_sources(h), until_after_sources=T_HARMINV)
    modes = sorted([(m.freq, m.Q, abs(m.amp), abs(m.err)) for m in h.modes if m.Q > 0 and FCEN - 0.5 * DF <= m.freq <= FCEN + 0.5 * DF])
    harm[res] = modes
    sim.reset_meep()
    say(f"A [res {res}]: " + "; ".join(f"f {f:.5f} Q {q:.0f} |amp| {a:.2e} err {e:.1e}" for f, q, a, e in modes))
modes_ref = harm[RES_IMG]
fsr = np.diff([m[0] for m in modes_ref])
ng = 1 / (np.mean(fsr) * L_RING)
say(f"A: FSR {', '.join(f'{x:.4f}' for x in fsr)} -> effective group index n_g = 1 / (FSR L) = {ng:.2f} (ring index {N_RING}); {time.time() - t_a:.0f} s")
if MASTER:
    source_figure(FCEN, DF, os.path.join(OUT, "00_source.png"), wl_scale=1.0, wl_unit="um", time_unit="um/c")

# ================================================================ B. one narrow-band run per resonance: field image + azimuthal order
imgs = []
t_b = time.time()
for f0, q0, _, _ in modes_ref:
    df0 = 0.01
    src = [mp.Source(mp.GaussianSource(f0, fwidth=df0), mp.Ez, SRC_PT)]
    sim = make_sim(RES_IMG, src)
    dft = sim.add_dft_fields([mp.Ez], f0, 0, 1, where=NONPML)
    sim.run(until_after_sources=mp.stop_when_fields_decayed(50, mp.Ez, SRC_PT, 1e-6))
    ez = sim.get_dft_array(dft, mp.Ez, 0)
    t_end = sim.meep_time()
    sim.reset_meep()
    # azimuthal order: sample the DFT field on the ring's mid-circle and count the dominant Fourier index
    nx, ny = ez.shape
    xs = np.linspace(EXT[0], EXT[1], nx); ys = np.linspace(EXT[2], EXT[3], ny)
    phis = np.linspace(0, 2 * np.pi, 720, endpoint=False)
    ix = np.clip(np.searchsorted(xs, R_MID * np.cos(phis)), 0, nx - 1); iy = np.clip(np.searchsorted(ys, R_MID * np.sin(phis)), 0, ny - 1)
    ring_vals = ez[ix, iy]
    spec = np.abs(np.fft.rfft(np.real(ring_vals)))
    m_az = int(np.argmax(spec[1:]) + 1)
    imgs.append({"f": f0, "Q": q0, "ez": ez, "m": m_az, "t_end": t_end, "ring_vals": ring_vals})
    say(f"B [f {f0:.4f}]: azimuthal order m = {m_az} (m / (n L f) = {m_az / (N_RING * L_RING * f0):.3f}); run ended at t = {t_end:.0f}")
say(f"B done in {time.time() - t_b:.0f} s")

# ================================================================ C. solve_cw at f = 0.118 vs a time-domain DFT of the same mode
F_CW = modes_ref[0][0]
sym_cw = (mp.Mirror(mp.X, phase=-1), mp.Mirror(mp.Y, phase=+1))
src_cw = [mp.Source(mp.ContinuousSource(F_CW), component=mp.Ez, center=mp.Vector3(R + 0.1)),
          mp.Source(mp.ContinuousSource(F_CW), component=mp.Ez, center=mp.Vector3(-(R + 0.1)), amplitude=-1)]
TOLS = (1e-8, 1e-10, 1e-12)
MAXITERS, L_BICG = 10000, 10
sim = make_sim(RES_IMG, src_cw, sym_cw, force_complex_fields=True)
cw = []
t_c = time.time()
for tol in TOLS:
    sim.init_sim()
    t1 = time.time()
    sim.solve_cw(tol, MAXITERS, L_BICG)
    cw.append((tol, sim.get_array(vol=NONPML, component=mp.Ez), time.time() - t1))
eps_cw = sim.get_array(vol=NONPML, component=mp.Dielectric)
sim.reset_meep()
ref = cw[-1][1]
cw_err = [float(np.linalg.norm(a - ref) / np.linalg.norm(ref)) for _, a, _ in cw[:-1]]
say("C: solve_cw " + "; ".join(f"tol {t:.0e}: {s:.0f} s" for t, _, s in cw) + " | rel error vs tightest: " + ", ".join(f"{t:.0e}: {e:.2e}" for (t, _, _), e in zip(cw[:-1], cw_err)))

src_td = [mp.Source(mp.GaussianSource(F_CW, fwidth=0.08), component=mp.Ez, center=mp.Vector3(R + 0.1)),
          mp.Source(mp.GaussianSource(F_CW, fwidth=0.08), component=mp.Ez, center=mp.Vector3(-(R + 0.1)), amplitude=-1)]
sim = make_sim(RES_IMG, src_td, sym_cw)
dft = sim.add_dft_fields([mp.Ez], F_CW, 0, 1, where=NONPML)
sim.run(until_after_sources=mp.stop_when_fields_decayed(50, mp.Ez, mp.Vector3(R + 0.1523), 1e-8))
ez_td = sim.get_dft_array(dft, mp.Ez, 0); t_td = sim.meep_time()
sim.reset_meep()
alpha = np.vdot(ez_td, ref) / np.vdot(ez_td, ez_td)          # best-fit complex scale: CW and DFT differ by amplitude and global phase
err_td = float(np.linalg.norm(alpha * ez_td - ref) / np.linalg.norm(ref))
corr = float(np.corrcoef(np.abs(ez_td).ravel(), np.abs(ref).ravel())[0, 1])
say(f"C: time-domain DFT (decay 1e-8, ended t = {t_td:.0f}) vs solve_cw after complex alignment: rel L2 {err_td:.4f}, |Ez| correlation {corr:.6f}; {time.time() - t_c:.0f} s")

# ================================================================ GIF: broadband pulse rings the resonator (monitor-free)
sim_g = make_sim(RES_IMG, [mp.Source(mp.GaussianSource(FCEN, fwidth=DF), mp.Ez, SRC_PT)])
sim_g.init_sim()
eps_g = sim_g.get_array(vol=NONPML, component=mp.Dielectric)
t0g = 5 / DF
frames, times = record_frames(sim_g, NONPML, mp.Ez, t_start=t0g - 1 / DF, t_end=t0g + 260, n_frames=80)
sim_g.reset_meep()

# ================================================================ figures (master only)
if MASTER:
    # A: Harminv results vs resolution
    fig, ax = plt.subplots(1, 2, figsize=(11, 4.0))
    cols = {10: "tab:gray", 20: "tab:blue", 30: "tab:red"}
    for j, (res, modes) in enumerate(harm.items()):
        ax[0].plot([m[0] for m in modes], [m[1] for m in modes], "o-", color=cols[res], label=f"res {res}: Q = " + " / ".join(f"{m[1]:.0f}" for m in modes))
    ax[0].set_yscale("log"); ax[0].set_xlabel("resonance frequency f [c/a]"); ax[0].set_ylabel("Q (Harminv)")
    ax[0].set_title("three Ez modes in the band 0.10-0.20: Q climbs with f (less bending radiation)", fontsize=9); ax[0].grid(alpha=0.3, which="both"); ax[0].legend(fontsize=8, loc="upper left")
    for k, (f, q, _, _) in enumerate(modes_ref):
        ax[1].axvline(f, color="tab:blue", lw=1.2); ax[1].text(f, 0.88, f"m = {imgs[k]['m']}\nf = {f:.4f}", ha="center", fontsize=8, color="tab:blue")
    ax[1].axvspan(FCEN - 0.5 * DF, FCEN + 0.5 * DF, color="orange", alpha=0.12, label="source band")
    for k in range(len(fsr)):
        ax[1].annotate("", xy=(modes_ref[k + 1][0], 0.5), xytext=(modes_ref[k][0], 0.5), arrowprops=dict(arrowstyle="<->", color="k"))
        ax[1].text(0.5 * (modes_ref[k][0] + modes_ref[k + 1][0]), 0.55, f"FSR {fsr[k]:.4f}", ha="center", fontsize=8)
    ax[1].text(0.102, 0.15, f"1 / (n_g L) with n_g = {ng:.2f}, L = 2 pi {R_MID} = {L_RING:.2f}", fontsize=8)
    ax[1].set_xlim(0.095, 0.205); ax[1].set_ylim(0, 1); ax[1].set_yticks([]); ax[1].set_xlabel("f [c/a]"); ax[1].set_title("free spectral range and azimuthal order (res 20)", fontsize=9); ax[1].legend(fontsize=8, loc="lower right")
    fig.tight_layout(); fig.savefig(os.path.join(OUT, "02_harminv.png"), dpi=150); plt.close(fig)

    # B: mode images
    fig, ax = plt.subplots(2, 3, figsize=(13, 8.2), gridspec_kw={"height_ratios": [1.6, 1]})
    for k, d in enumerate(imgs):
        ez = d["ez"]; lim = float(np.percentile(np.abs(ez), 99.5))
        ax[0, k].imshow(np.real(ez).T, extent=EXT, origin="lower", cmap="RdBu", vmin=-lim, vmax=lim, aspect="equal")
        ax[0, k].contour(np.linspace(EXT[0], EXT[1], eps_cw.shape[0]), np.linspace(EXT[2], EXT[3], eps_cw.shape[1]), eps_cw.T, levels=[0.5 * (1 + N_RING ** 2)], colors="k", linewidths=0.6)
        ax[0, k].plot(R + 0.1, 0, "o", color="lime", ms=4)
        ax[0, k].set_title(f"f = {d['f']:.4f} (lambda = {1 / d['f']:.2f} a), Q = {d['Q']:.0f}, m = {d['m']}", fontsize=9); ax[0, k].set_xlabel("x [a]")
        ax[1, k].plot(np.degrees(np.linspace(0, 2 * np.pi, 720, endpoint=False)), np.real(d["ring_vals"]) / np.max(np.abs(d["ring_vals"])), color="tab:blue", lw=1)
        ax[1, k].set_xlabel("angle around the ring [deg]"); ax[1, k].set_title(f"Re(Ez) on the mid-circle r = {R_MID}: {d['m']} periods", fontsize=9); ax[1, k].grid(alpha=0.3); ax[1, k].set_xlim(0, 360)
    ax[0, 0].set_ylabel("y [a]"); ax[1, 0].set_ylabel("normalized")
    fig.suptitle("each resonance imaged alone (narrow-band source, DFT at the resonance): the azimuthal order m counts the wavelengths around the ring", fontsize=10)
    fig.tight_layout(); fig.savefig(os.path.join(OUT, "03_modes.png"), dpi=150); plt.close(fig)

    # C: solve_cw
    fig = plt.figure(figsize=(13, 4.4))
    ax = fig.add_subplot(1, 3, 1)
    ax.loglog([t for t, _, _ in cw[:-1]], cw_err, "bo-"); ax.invert_xaxis()
    for (t, _, s), e in zip(cw[:-1], cw_err):
        ax.annotate(f"{s:.0f} s", (t, e), textcoords="offset points", xytext=(6, -12), fontsize=8)
    ax.set_xlabel("solve_cw tolerance"); ax.set_ylabel(f"relative error vs tol {TOLS[-1]:.0e} field"); ax.set_title("frequency-domain solver: tighter tolerance, smaller change", fontsize=9); ax.grid(alpha=0.3, which="both")
    lim = float(np.percentile(np.abs(ref), 99.5))
    for a, data, ttl in ((fig.add_subplot(1, 3, 2), np.real(ref), f"solve_cw at f = {F_CW:.4f} (tol {TOLS[-1]:.0e})"),
                         (fig.add_subplot(1, 3, 3), np.real(alpha * ez_td), f"time-domain DFT, aligned: rel L2 {err_td:.3f}")):
        a.imshow(data.T, extent=EXT, origin="lower", cmap="RdBu", vmin=-lim, vmax=lim, aspect="equal")
        a.contour(np.linspace(EXT[0], EXT[1], eps_cw.shape[0]), np.linspace(EXT[2], EXT[3], eps_cw.shape[1]), eps_cw.T, levels=[0.5 * (1 + N_RING ** 2)], colors="k", linewidths=0.6)
        a.set_title(ttl, fontsize=9); a.set_xlabel("x [a]")
    fig.suptitle("the same mode from two solvers: continuous source + BiCGSTAB-L (left, centre) and a pulse + DFT (right)", fontsize=10)
    fig.tight_layout(rect=[0, 0, 1, 0.93]); fig.savefig(os.path.join(OUT, "04_solve_cw.png"), dpi=150); plt.close(fig)

    animate_fields(frames, times, EXT, os.path.join(OUT, "05_anim_ring.gif"), eps=eps_g, figsize=(5.6, 5.0), dpi=70, clip_percentile=99.0, unit="a",
                   points=[(R + 0.1, 0, "red", "source / probe")], title="broadband pulse, then ringing", legend_loc="lower left")

    with open(os.path.join(OUT, "result.json"), "w") as f_:
        json.dump({"params": {"n": N_RING, "r": R, "w": W, "pad": PAD, "dpml": DPML, "fcen": FCEN, "df": DF, "T_harminv": T_HARMINV, "L_ring": L_RING},
                   "harminv": {str(k): [{"f": f, "Q": q, "amp": a, "err": e} for f, q, a, e in v] for k, v in harm.items()},
                   "fsr": fsr.tolist(), "n_g": float(ng),
                   "modes": [{"f": d["f"], "Q": d["Q"], "m": d["m"], "t_end": float(d["t_end"])} for d in imgs],
                   "solve_cw": {"f": F_CW, "tols": list(TOLS), "seconds": [s for _, _, s in cw], "rel_err_vs_tightest": cw_err,
                                "td_vs_cw_rel_l2": err_td, "td_vs_cw_corr": corr, "td_t_end": float(t_td)},
                   "wall_s_total": time.time() - t_all, "meep": mp.__version__, "np": mp.count_processors()}, f_, indent=2)
say(f"total {time.time() - t_all:.0f} s on {mp.count_processors()} process(es)")

§4의 발췌 코드와 달리 전체 코드에는 해상도 사다리, 모드 영상과 방위 차수 계산, solve_cw sweep, GIF, result.json 기록이 들어 있다. MPI로 돌릴 수 있게 collective 호출(run, get_array, solve_cw)은 모든 rank에서, 그림 저장은 master rank에서만 한다. 그림 helper blogfig.py는 시리즈 공통이며 같은 폴더(code/)에 있다. 전체 코드와 helper: https://github.com/jin-castle/meep-examples/blob/main/code.

실행 결과 (2026-10-23 실행, mpirun -np 4):

A [res 10]: f 0.11810 Q 81 |amp| 3.41e-03 err 1.0e-05; f 0.14716 Q 317 |amp| 2.86e-02 err 7.3e-07; f 0.17525 Q 1675 |amp| 7.21e-03 err 2.0e-07
A [res 20]: f 0.11818 Q 79 |amp| 3.51e-03 err 6.8e-06; f 0.14736 Q 342 |amp| 2.81e-02 err 1.7e-07; f 0.17564 Q 2132 |amp| 6.76e-03 err 1.4e-06
A [res 30]: f 0.11822 Q 79 |amp| 3.52e-03 err 2.6e-06; f 0.14740 Q 336 |amp| 2.82e-02 err 1.5e-07; f 0.17572 Q 1610 |amp| 6.79e-03 err 9.7e-08
A: FSR 0.0292, 0.0283 -> effective group index n_g = 1 / (FSR L) = 3.69 (ring index 3.4)
B [f 0.1182]: azimuthal order m = 3 (m / (n L f) = 0.792); run ended at t = 2101
B [f 0.1474]: azimuthal order m = 4 (m / (n L f) = 0.847); run ended at t = 5453
B [f 0.1756]: azimuthal order m = 5 (m / (n L f) = 0.888); run ended at t = 19110
C: solve_cw tol 1e-08: 5 s; tol 1e-10: 6 s; tol 1e-12: 7 s | rel error vs tightest: 1e-08: 4.24e-07, 1e-10: 1.08e-10
C: time-domain DFT (decay 1e-8, ended t = 2001) vs solve_cw after complex alignment: rel L2 0.0040, |Ez| correlation 0.999984
total ~4 min on 4 processes

재현 환경: meep 1.33.0 (MPI) · Python 3.11 · conda install -c conda-forge pymeep=*=mpi_mpich_* · 실행 mpirun -np 4 python ring_resonator.py (약 4 min (mpirun -np 4))

심화 질문: 다음 편과 연결하기
  1. Harminv는 300 time unit의 신호로 수명이 수천인 모드의 Q를 준다. 그것이 가능한 이유와, 그 Q를 믿어도 되는 조건(error)을 말해 보라.
  2. 주파수는 해상도 10에서 1% 안인데 Q는 해상도 30에서도 수렴하지 않았다. 두 양의 수렴 속도가 다른 이유를 굽힘 방사와 격자로 설명해 보라.
  3. 이 고리는 2D 단면이다. 실제 마이크로디스크는 축대칭 3D 구조이고 모드는 방위 차수 m을 가진다. 3D 셀을 돌리지 않고 m 하나당 2D 계산으로 끝내는 좌표계는 무엇이고, 그때 m은 어디에 들어가는가. (13편)

더 읽기

]]>jin-castleMeep Example 05 · Bent waveguide와 radius trade-off — 2-run flux 정규화, sharp bend 기준값, radius sweep2026-10-23T00:00:00+00:002026-10-23T00:00:00+00:00https://jin-castle.github.io/meep-examples/waveguide-bend-90 English summary
  • What: a dielectric waveguide (ε = 12, width 1) turns a sharp 90° corner. We measure how much power goes around the corner, how much comes back, and how much leaks out.
  • Result: T = 0.20, R = 0.22, radiated = 0.58 at the center wavelength. Most of the light is lost at the sharp corner. Rounding it recovers the light: T = 0.91 at a bend radius of 0.35 µm and 0.99 at 0.70 µm.
  • Takeaway: two-run flux normalization. A straight reference run gives the input power and the incident fields; subtracting them in the bend run leaves only the reflection. A sharp corner is not usable in a photonic circuit.
  • Code: full script at the bottom, ~95 s on one core (the sharp bend alone takes 10 s).

1. 관찰 · 빛의 경로를 먼저 보기

같은 폭의 도파로를 직각으로 꺾었습니다. 입력은 왼쪽, 출력은 위쪽입니다. 수평 암에서 코너까지 온 파면이 수직 암으로만 이어지는지, 주변 공기로도 퍼지는지 보세요. 필드의 밝기를 바로 투과율로 읽지 말고 뒤의 flux 측정과 연결합니다.

날카로운 L자 도파로의 실제 Re(Ez)와 진폭. 코너 밖으로 방사파가 퍼지고 출력 암은 약하다.
1550 nm의 실제 필드입니다. 가는 선은 도파로 경계이며, 코너 바깥의 파면과 입력 암의 정상파가 각각 방사와 반사의 단서입니다.
날카로운 코너에서 펄스가 반사·방사·투과로 나뉘는 시간 전개
sharp 코너의 시간 전개. 펄스가 코너에 닿는 순간 cladding으로 큰 파면이 퍼져 나가고, 수직 암으로는 일부만 올라간다. 되돌아오는 파가 수평 암에서 입사파와 겹친다.
반지름 3a의 둥근 코너를 따라 펄스가 출력으로 이동하는 시간 전개
반지름 3a 코너의 시간 전개. 같은 펄스가 코너를 돌아 수직 암 위의 투과 단면(파란 선)까지 거의 그대로 간다.

2. 예측 · 결과를 읽기 전에

재료가 빛을 흡수하지 않아도, 위쪽 도파로로 나가는 몫 T는 줄어들 수 있을까요?

먼저 하나를 골라보세요.
예측의 근거 확인하기

두 번째입니다. 손실 없는 재료라는 말은 출력 도파로가 모든 power를 받는다는 뜻이 아닙니다. 입력으로 되돌아가는 반사 R과 주변 공기로 새는 방사 L도 함께 세어야 합니다. 이 구조에서는 방사가 가장 큰 몫인지 측정으로 확인합니다.

3. 원리 이해하기 · 관찰을 설명하는 방법

직선 기준, 날카로운 L자 굽힘, 둥근 굽힘을 비교한다. 입력은 왼쪽, 출력은 위쪽이며 날카로운 코너의 반사와 바깥 방사 경로를 표시한다.
공기 속 ε = 12 유전체 도파로에서 직선 기준과 날카로운 직각, 둥근 굽힘을 비교합니다. 유효 입사광은 왼쪽에서 +x 방향으로 들어오고 출력은 위쪽 +y 방향입니다. 코너에서는 투과·반사·바깥 방사가 나뉠 수 있습니다. 그림의 R ≈ 0.70 µm는 둥근 굽힘의 중심선 곡률반경 0.6975 µm를 반올림한 값입니다. 점선은 위치 안내선입니다. 화살표 굵기는 계산된 전력 비율을 나타내지 않습니다. 파장을 1550 nm로 읽는 이 글의 환산에서 폭은 232.5 nm입니다.

먼저 직선에서 기준을 만든다

기준 run은 같은 재료·폭·source를 가진 직선 도파로입니다. 여기서 실제로 전달된 power를 입력값 P_in으로 저장하고, 반사 단면에서는 입사장의 DFT 데이터를 저장합니다. 굽힘 run에서는 같은 반사 단면에 load_minus_flux_data를 적용해 필드 수준에서 입사 성분을 뺍니다. power 숫자끼리 빼면 간섭항이 남습니다.

출력, 되돌아옴, 바깥으로 샘을 나눈다

\[T=P_{\mathrm{tran}}/P_{\mathrm{in}},\qquad R=-P_{\mathrm{refl}}/P_{\mathrm{in}},\qquad L=1-T-R\]

반사파는 −x로 가므로 flux가 음수이고, R 앞의 마이너스가 이를 양의 비율로 바꿉니다. 투과 monitor는 +y로 가는 빛을 가로지르는 가로선이어야 합니다. 코너가 급할수록 모드의 방향과 모양이 갑자기 바뀌어 반사·방사가 생깁니다. 둥근 코너는 그 변화를 완만하게 만듭니다.

기호·설계 가정과 예측표 자세히 보기

도파로를 따라가던 모드는 코너에서 갑자기 방향이 바뀐 도파로를 만난다. 입력 모드와 수직 암의 모드는 모양이 겹치는 부분이 작아서(mode mismatch), 겹치지 않는 부분만큼 밖으로 방사되거나 되돌아간다. 닫힌 해석해는 없고, 에너지 보존이 결과를 구속한다.

\[T=\frac{P_{\mathrm{tran}}}{P_{\mathrm{in}}},\qquad R=\frac{-P_{\mathrm{refl}}}{P_{\mathrm{in}}},\qquad T+R+L_{\mathrm{rad}}=1\]
기호 뜻 코드 변수
$P_{\mathrm{in}}$ 직선 기준 run에서 도파로를 지나간 power P_in
$P_{\mathrm{tran}}$ bend run에서 수직 암 단면을 지나는 power mp.get_fluxes(tran)
$P_{\mathrm{refl}}$ bend run의 반사 단면 flux. 입사 성분을 뺀 값이라 뒤로 가는 power만 남고 음수 mp.get_fluxes(refl)
$L_{\mathrm{rad}}$ 코너에서 밖으로 새는 power. 직접 재지 않고 잔여로 추정 L = 1 - T - R

가정과 유효 범위: 2D, lossless 재료(잔여는 전부 방사), Ez 편광(면에 수직한 전기장), 공식 예제의 무차원 단위(길이 단위 a, ε = 12, 파장 6.67a). 그림에서는 a = 232.5 nm로 읽어 중심 파장을 1550 nm, 길이를 µm로 표시한다.

결과 보기 전에 맞춰보기

물리량 내 예측 근거
T 0.5 미만, 수십 % 굴절률 대비가 크고(√12 ≈ 3.5) 코너가 급해 모드 겹침이 작다
R 수십 % 코너 벽이 거울처럼 일부를 되돌린다
L (방사) 가장 큰 몫 코너에서 위상이 맞는 방향이 없어 대부분 밖으로 흩어진다
필드 모양 코너 주변 cladding으로 퍼지는 방사 lobe, 수직 암은 희미 mode mismatch
T + R 1 이하 에너지 보존

판정 기준: 이 sharp 구조의 낮은 T와 에너지 수지를 먼저 확인합니다. 작은 T + R 초과는 수치 오차일 수 있으므로 부호·정규화와 수렴성을 함께 점검합니다.

4. 직접 실행 · 변수 하나만 바꾸기

한 번만 바꿔보기: 도파로 폭

  1. 아래 전체 코드와 공통 blogfig.py를 같은 code/ 폴더에 두고, 그 폴더에서 python bend90.py를 실행합니다. 원본의 w = 1.0 결과와 result.json을 별도 보관합니다.
  2. w = 1.0 한 줄만 w = 0.8로 바꿔 다시 실행합니다. 재료·파장·반지름 목록·해상도는 그대로 둡니다.
  3. 두 실행의 radius_sweep에서 같은 반지름의 T·R·L을 비교합니다. T가 0.9를 넘는 첫 반지름과 sharp bend의 T도 적어 보세요.

폭이 바뀌면 모드의 구속과 코너에서의 겹침도 바뀝니다. 어느 반지름에서 차이가 커질지 먼저 예상해 보세요. 폭 0.8의 결과는 이 글에 측정되어 있지 않으며, 원본 곡선은 폭 1.0의 기준입니다. 실행할 때 출력 파일이 갱신되므로 비교용 기준 결과를 먼저 보관합니다.

계산 배치·광원·파라미터 보기
L자 도파로의 광원, 반사·투과 flux 단면, PML과 종료 감시점
검은 L자 = 수평 암 + 수직 암(`geometry`, 양 끝이 PML 관통), 빨간 선 = Ez line source(x = −6.5), 파란 세로선 = 반사 flux 단면(x = −5.5, source 하류), 파란 가로선 = 투과 flux 단면(y = +6.5, 수직 암 위), 녹색 빗금 = PML, 보라 × = bend run의 종료 조건이 감시하는 점(4, 6.5). 좌표는 코드의 a 단위이고 축 눈금은 a = 232.5 nm로 환산한 µm다(cell 16a = 3.72 µm). 동그라미 숫자는 §4의 코드 단계 번호다. ① 파라미터 박스, ② 구조, ③ source, ④ PML, ⑤ monitor, ⑥ 종료 감시점이고, ⑦ 후처리는 그릴 것이 없다. 기준 run(직선)은 같은 source·반사 단면에 수평 암만 쭉 이어진 구조다.
파라미터 값 왜 이 값인가 바꾸면
eps_wg, w 12, 1 공식 튜토리얼 값 (n ≈ 3.46) ε 낮추면 confinement 약해져 L ↑
fcen, df 0.15, 0.1 파장 6.67a = 1550 nm (a = 232.5 nm). 대역 5–10a = 1160–2325 nm 대역 가장자리는 source power가 작아 값이 튄다
resolution 25 공식 10 → 상향. 도파로 폭 25 px, 유도 파장 48 px 10이면 코너 형상이 거칠어 수치 변동
dpml 1.0 파장의 1/6 이상. 양 암이 PML을 관통 얇으면 PML 반사가 R에 섞임
sx = sy 16 코너 주변 방사가 PML에 닿기 전 퍼질 여유 좁히면 방사가 monitor에 되돌아옴
src_x, refl_x −6.5, −5.5 source는 PML 밖 0.5, 반사 단면은 source 하류 1.0 반사 단면이 source 상류면 입사 성분 분리 실패
span w + 2 core 양쪽 1a씩 evanescent tail 포함 core 폭만 잡으면 P_in 과소 → T 과대
굽힘 실험 가우시안 광원의 시간 파형과 대역 끝이 약한 스펙트럼
source의 시간 파형(왼쪽)과 power 스펙트럼(오른쪽). width = 1/fwidth = 10, 펄스 정점 t0 = 50. monitor 대역(1162–2325 nm) 가장자리의 source power는 중심의 0.005%다. 그래서 §5 스펙트럼의 양 끝 값은 0에 가까운 수를 0에 가까운 수로 나눈 것이고, 경향만 본다.

강의 노트북과의 차이: 강의 week 6은 n 3.4/1.44, 폭 0.6 µm의 곡선 bend에서 radius 0.6–3.0 µm를 훑는다. 이 글은 공식 sharp bend(ε = 12, w = 1a)를 기준값으로 두고, 같은 구조의 코너만 둥글려 radius를 훑는다.

코드 단계별 설명 보기

읽는 순서는 04편과 같다: 단위·파라미터 → 재료·구조 → source → Simulation·경계 → monitor → 실행·종료 → 후처리. 이번에는 run이 두 번이라 ⑤·⑥이 기준 run과 bend run에 한 번씩 나온다.

① 단위와 파라미터 — 어떤 숫자를 고정하는가

import numpy as np
import meep as mp

# Dimensionless units as in the official tutorial: 1 length unit = a (think 1 um).
eps_wg = 12.0            # waveguide permittivity (n = sqrt(12) = 3.46)
w = 1.0                  # waveguide width
fcen = 0.15              # center frequency -> wavelength 1/0.15 = 6.67 units
df = 0.1                 # source bandwidth
nfreq = 11               # number of frequencies in the flux monitors

resolution = 25          # pixels per unit -> width = 25 px, wavelength in the guide (1.92) = 48 px
dpml = 1.0               # PML thickness
sx = sy = 16.0           # square cell, PML included

ycen = -4.0              # y of the input (horizontal) arm
xcen = +4.0              # x of the output (vertical) arm  -> corner at (xcen, ycen)

src_x = -6.5             # source: 0.5 outside the left PML (PML edge at x = -7)
refl_x = -5.5            # reflection flux plane: downstream of the source
tran_straight_x = +6.5   # transmission plane for the straight reference run
tran_bend_y = +6.5       # transmission plane for the bend run (on the vertical arm)
span = mp.Vector3(0, w + 2)   # source / monitor line: core + 1 unit on each side (evanescent tail)
  • 무엇: 공식 튜토리얼의 무차원 설정(ε = 12, w = 1, f = 0.15)과 코너 위치, source·monitor 좌표를 고정한다.
  • 왜: 04편은 1 = 1 µm였지만 여기서는 길이 단위 a를 정하지 않는다. Maxwell 방정식은 scale-invariant라서 a = 1 µm로 읽으면 파장 6.67 µm, a = 0.23 µm로 읽으면 1.55 µm 결과가 그대로 된다. 이 글의 그림은 그 둘째 읽기(a = 232.5 nm)로 환산해 파장은 nm, 길이는 µm로 표시한다. 좌표는 모두 PML 경계(±7)를 기준으로 잡는다.
  • 틀리면: refl_x를 source보다 왼쪽(상류)에 두면 입사 펄스가 그 단면을 지나지 않아 load_minus_flux_data가 뺄 것이 없고 R이 엉뚱해진다.

함정: df = 0.1은 대역 5–10a로 넓다. 가장자리 파장에서는 source power가 거의 없어 T·R이 튄다. 중심 근처만 믿는다(§5).

② 재료와 구조 — 무엇이 어디에 있는가

def make_geometry(bend: bool):
    """Straight reference (bend=False) or the L-shaped bend (bend=True). Same width and material."""
    wg = mp.Medium(epsilon=eps_wg)
    if not bend:
        return [mp.Block(center=mp.Vector3(0, ycen), size=mp.Vector3(mp.inf, w), material=wg)]
    horizontal = mp.Block(center=mp.Vector3(0.5 * (-sx / 2 + xcen + w / 2), ycen),
                          size=mp.Vector3(sx / 2 + xcen + w / 2, w), material=wg)   # left PML -> corner
    vertical = mp.Block(center=mp.Vector3(xcen, 0.5 * (ycen - w / 2 + sy / 2)),
                        size=mp.Vector3(w, sy / 2 - ycen + w / 2), material=wg)     # corner -> top PML
    return [horizontal, vertical]
  • 무엇: 같은 함수가 플래그 하나로 직선 기준 구조와 L자 bend 구조를 만든다. 두 Block은 코너에서 폭 w만큼 겹쳐 빈틈 없는 직각을 이룬다.
  • 왜: 기준 run과 bend run은 구조만 다르고 나머지는 같아야 정규화가 성립한다. 함수로 묶으면 재료·폭·좌표가 어긋날 여지가 없다. 수평 암은 왼쪽 PML을, 수직 암은 위쪽 PML을 관통해야 끝면 반사가 없다.
  • 틀리면: 수평 암을 코너에서 xcen - w/2까지만 그리면 코너에 빈 사각형이 생겨 R이 커진다. 수직 암이 cell 안에서 끝나면 끝면 반사가 T에 섞인다.

②′ 둥근 코너 — 사분원 고리

r = radius
cx, cy = xcen - r, ycen + r                      # center of the quarter ring
big = r + w / 2 + 1.0
geom = [mp.Cylinder(radius=r + w / 2, center=mp.Vector3(cx, cy), material=wg),    # outer disk: waveguide
        mp.Cylinder(radius=r - w / 2, center=mp.Vector3(cx, cy), material=air),   # inner disk: air -> ring
        # keep only the lower-right quadrant (x > cx, y < cy): cover the other three with air
        mp.Block(center=mp.Vector3(cx - big / 2, cy), size=mp.Vector3(big, 2 * big), material=air),
        mp.Block(center=mp.Vector3(cx + big / 2, cy + big / 2), size=mp.Vector3(big, big), material=air)]
# the two arms are appended AFTER this list, so they are drawn on top of the air blocks
  • 무엇: 반지름 r + w/2의 원판에서 r − w/2의 원판을 빼 고리를 만들고, 공기 블록으로 세 사분면을 덮어 오른쪽 아래 1/4만 남긴다. 수평 암은 x = xcen − r에서, 수직 암은 y = ycen + r에서 고리와 만난다.
  • 왜: Meep의 geometry는 나중 객체가 앞 객체를 덮어쓴다. 그래서 “원판 → 공기 원판 → 공기 블록 → 암” 순서가 곧 차집합 연산이다. r = 0이면 고리가 없고 sharp 코너로 돌아간다.
  • 틀리면: 암을 공기 블록보다 먼저 넣으면 블록이 암의 끝을 지운다. 공기 블록을 빠뜨리면 고리 전체가 남아 도파로가 원을 그린다.

③ Source — 빛을 어떻게 넣는가

# A plain Ez line source (not an eigenmode source), as in the official tutorial.
sources = [mp.Source(mp.GaussianSource(fcen, fwidth=df), component=mp.Ez,
                     center=mp.Vector3(src_x, ycen), size=span)]
  • 무엇: 수평 암을 가로지르는 길이 3a의 세로선에서 Ez 성분 가우시안 펄스를 쏜다.
  • 왜: 04편의 EigenModeSource와 달리 모드 모양을 맞추지 않은 단순 선 source다. 모드가 아닌 성분도 섞여 들어가지만, 기준 run이 실제로 도파로를 따라간 power를 재므로 그 몫은 P_in에서 빠진다. 2-run 정규화가 필요한 이유 중 하나다.
  • 틀리면: component를 Ey로 바꾸면 2D에서 면내 편광이 되어 다른 모드(다른 confinement)를 보게 된다. size를 core 폭만큼만 잡아도 돌아가지만 모드 결합이 나빠져 방사 잡음이 늘어난다.

④ Simulation과 경계 — 계산 상자와 PML

def make_sim(bend: bool):
    return mp.Simulation(cell_size=mp.Vector3(sx, sy), resolution=resolution,
                         boundary_layers=[mp.PML(dpml)],
                         geometry=make_geometry(bend), sources=sources)
  • 무엇: 16 × 16 상자, 네 변 PML 1a, 같은 source·해상도로 구조만 바꿔 Simulation을 만드는 함수.
  • 왜: Meep의 Simulation 객체는 run이 끝나면 필드가 남아 있어 재사용하기 어렵다. 매 run마다 새로 만드는 것이 가장 안전하고, 함수로 묶으면 두 run의 설정 일치가 보장된다.
  • 틀리면: 두 run에서 resolution이나 cell_size가 다르면 격자 위치가 달라져 load_minus_flux_data가 크기가 다른 배열을 빼려다 오류를 낸다.

⑤ Monitor — 무엇을 재는가 (기준 run)

sim = make_sim(bend=False)
refl  = sim.add_flux(fcen, df, nfreq, mp.FluxRegion(center=mp.Vector3(refl_x, ycen), size=span))
tran0 = sim.add_flux(fcen, df, nfreq, mp.FluxRegion(center=mp.Vector3(tran_straight_x, ycen), size=span))
  • 무엇: 직선 구조에 반사 단면(x = −5.5)과 투과 단면(x = +6.5)을 둔다. add_flux는 그 선을 지나는 Poynting flux를 주파수별로 누적한다.
  • 왜: 직선은 반사가 없으므로 투과 단면 flux가 곧 source가 도파로에 넣은 power P_in이다. 반사 단면은 이 run에서는 입사 펄스를 기록하는 용도다.
  • 틀리면: 투과 단면을 PML 안에 두면 이미 흡수된 값을 재서 P_in이 작아지고 T가 과대평가된다.

⑥ 실행과 종료 조건 (기준 run)

sim.run(until_after_sources=mp.stop_when_fields_decayed(
            25, mp.Ez, mp.Vector3(tran_straight_x, ycen), 1e-6))

P_in = np.array(mp.get_fluxes(tran0))     # what actually travels down the guide = input power
refl_data = sim.get_flux_data(refl)       # incident fields at the reflection plane (to subtract later)
freqs = np.array(mp.get_flux_freqs(tran0))
  • 무엇: 투과 단면 근처의 Ez가 최대값의 10⁻⁶으로 줄 때까지 돌리고, P_in과 반사 단면의 DFT 필드 데이터를 꺼내 둔다.
  • 왜: get_fluxes는 숫자(power)지만 get_flux_data는 필드 자체다. 다음 run에서 필드 수준에서 빼야 간섭항까지 정확히 제거된다. power끼리 빼면 틀린다.
  • 틀리면: 종료가 이르면 펄스 꼬리가 단면을 다 지나지 못해 P_in이 작아지고, 다음 run의 입사 데이터도 불완전해 R에 잔여 입사 성분이 남는다.

⑤′ Monitor — 무엇을 재는가 (bend run)

sim = make_sim(bend=True)
refl = sim.add_flux(fcen, df, nfreq, mp.FluxRegion(center=mp.Vector3(refl_x, ycen), size=span))
sim.load_minus_flux_data(refl, refl_data)  # subtract the incident part -> this monitor now sees reflection only
tran = sim.add_flux(fcen, df, nfreq,
                    mp.FluxRegion(center=mp.Vector3(xcen, tran_bend_y), size=mp.Vector3(w + 2, 0)))
  • 무엇: bend 구조에 같은 위치의 반사 단면을 만들고, 기준 run의 입사 데이터를 음수로 미리 채운다. 투과 단면은 수직 암 위(y = +6.5)의 가로선이다.
  • 왜: 반사 단면에는 입사 펄스(오른쪽으로)와 반사 펄스(왼쪽으로)가 모두 지나간다. 입사 성분을 미리 빼 두면 run이 끝났을 때 반사 성분만 남는다.
  • 틀리면: 이 줄을 빼먹으면 반사 단면에 입사 성분도 남는다. 같은 부호식으로 계산한 R은 과소평가되거나 음수가 될 수 있다.

함정: 투과 단면의 size가 (w + 2, 0), 즉 가로선이다. 수직 암에서는 빛이 +y로 가므로 단면은 x 방향으로 펼쳐야 한다. span을 그대로 쓰면 세로선이 되어 빛과 평행하게 놓인다.

⑥′ 실행과 종료 조건 (bend run)

sim.run(until_after_sources=mp.stop_when_fields_decayed(
            25, mp.Ez, mp.Vector3(xcen, tran_bend_y), 1e-6))
  • 무엇: 이번에는 수직 암 끝(투과 단면 위치)의 Ez가 줄어들 때까지 돌린다.
  • 왜: 감시점은 빛이 마지막으로 지나가는 곳이어야 한다. bend에서는 그곳이 수직 암 끝이다.
  • 틀리면: 감시점을 기준 run과 같은 (+6.5, −4)로 두면 bend 구조에서는 그곳에 도파로가 없어 필드가 금방 사라지고, 투과 펄스가 다 지나기 전에 run이 끝난다.

⑦ 후처리 — 숫자로 바꾸기

T = np.array(mp.get_fluxes(tran)) / P_in      # transmitted fraction
R = -np.array(mp.get_fluxes(refl)) / P_in     # backward flux is negative -> flip the sign
L = 1.0 - T - R                               # what is left: radiated out at the corner
ic = nfreq // 2
print(f"T = {T[ic]:.4f}, R = {R[ic]:.4f}, radiation loss = {L[ic]:.4f}")
  • 무엇: 두 flux를 P_in으로 나눠 T·R을 얻고, 1에서 뺀 나머지를 방사 손실로 해석한다.
  • 왜: Meep의 flux는 방향이 있다. 반사 단면의 flux는 −x 방향이라 음수로 나오므로 부호를 뒤집어야 반사된 양이 된다. 1 - T - R은 방사 monitor를 따로 두지 않았을 때의 잔여 추정이다.
  • 틀리면: 부호를 안 뒤집으면 R이 음수, L이 1을 넘는다.

5. 해석 · 측정값과 한계를 함께 읽기

투과가 낮아진 이유를 숫자로 확인하기

1550 nm의 구조 T R L = 1 − T − R
날카로운 코너 0.1997 0.2202 0.5801
반지름 3a = 0.6975 µm 0.9859 0.0003 0.0138

sharp bend에서는 입력의 약 20%만 위쪽 암에 도달하고 잔여 방사가 약 58%입니다. 반지름을 늘리면 반사는 약 1a에서 먼저 작아지고, 방사는 더 천천히 줄어듭니다. 이 사례의 변화가 완만해지는 구간은 1.5–2a 부근입니다.

파장별 sharp bend의 투과율, 반사율과 잔여 방사율
중심 파장 1550 nm(점선) 근처에서 방사(초록)가 가장 크고 T(파랑)는 0.2 부근이다. 대역 가장자리(1160 nm, 2325 nm)는 source power가 작아 값이 튀므로 경향만 본다. 파장이 길수록 T가 올라가는 것은 모드가 덜 갇혀(cladding으로 더 퍼져) 코너의 급격함을 덜 느끼기 때문이다.
코너 반지름을 늘릴 때 투과율이 높아지고 반사·방사가 줄어드는 측정 곡선
같은 구조에서 코너 반지름만 바꿨을 때의 T, R, 방사. 반지름 0이 위의 sharp bend다. 축은 a = 232.5 nm로 환산한 µm.
반지름 3a인 둥근 도파로의 실제 Re(Ez)와 진폭 필드
반지름 3a = 0.70 µm. 수평 암의 정상파 마디가 사라지고(반사 0.03%), 코너 밖으로 새는 빛이 거의 없다.
전체 측정표·예측 비교·수렴성 기록 보기
물리량 값 @ 1550 nm (6.67a) 비교 대상
T 0.1997 공식 튜토리얼도 “낮은 T” 시연 목적
R 0.2202 —
L (방사, 잔여) 0.5801 —
T + R 0.4199 ≤ 1 성립

코너를 둥글리면: radius sweep

반지름 µm T R 방사
0 (sharp) 0 0.200 0.220 0.580
0.5a 0.12 0.487 0.052 0.462
1a 0.23 0.746 0.001 0.253
1.5a 0.35 0.907 0.001 0.092
2a 0.47 0.964 0.000 0.036
3a 0.70 0.986 0.000 0.014
4a 0.93 1.003 0.000 −0.003
6a 1.40 1.000 0.000 0.000

반사는 반지름 1a(파장의 1/7)에서 이미 사라진다. 방사는 더 천천히 줄어 1.5a에서 10% 아래로, 3a에서 1% 대로 내려간다. 손실이 꺾이는 무릎(knee)은 1.5–2a, 즉 도파로 안 파장(1.92a)의 한 배 근처다. 그보다 큰 반지름은 면적만 늘린다. 4a에서 T가 1을 0.3% 넘는 것은 정규화 run과 bend run의 수치 오차이지 이득이 아니다.

수렴성 (sharp bend)

resolution dpml T R 방사 비고
25 1.0 0.200 0.220 0.580 기준
10 1.0 0.198 0.229 0.573 공식 예제 해상도
40 1.0 0.189 0.224 0.587 해상도 1.6배
25 1.5 0.170 0.217 0.612 PML 두껍게. source·monitor 면이 0.5a 안쪽으로

해상도 10에서 40까지 T는 5% 안에서 움직인다. 그런데 PML을 두껍게 하면서 source와 monitor 면을 0.5a 안쪽으로 옮기자 T가 15% 내려갔다. 코너에서 방사된 빛이 투과 단면과 PML 사이에서 어떻게 잡히느냐에 따라 값이 달라진다는 뜻이다. sharp bend의 T = 0.20은 첫째 자리까지만 의미가 있다. 둥근 bend(R ≥ 2a)는 방사가 거의 없어서 이 민감도가 사라진다.

예측과 비교

물리량 내 예측 (§2) 시뮬레이션 판정
T 0.5 미만 0.20 ✅
R 수십 % 0.22 ✅
L 가장 큰 몫 0.58 ✅
필드 모양 코너 방사 lobe, 수직 암 희미 그림 확인 ✅
T + R ≤ 1 0.42 ✅

방향은 모두 맞았지만 T = 0.20이라는 값은 계산해 봐야 안다. T + R ≤ 1은 예측이 아니라 검산이다. 깨지면 물리가 아니라 코드가 틀린 것이다.

검증 체크: T + R = 0.42 ≤ 1 · source(x = −6.5)·반사 단면(−5.5)·투과 단면(y = 6.5) 모두 PML(|x|, |y| > 7) 밖 · 두 run 모두 field decay 기준 종료.

주장할 수 있는 것 / 없는 것

  • 할 수 있는 것: sharp bend는 power의 절반 이상을 방사로 잃는다. 반지름을 도파로 안 파장의 한 배(1.5–2a, 0.35–0.47 µm) 이상 주면 손실이 10% 아래로 떨어지고, 3a 이상에서는 더 얻을 것이 없다.
  • 할 수 없는 것: sharp bend의 T = 0.20의 둘째 자리. 해상도와 monitor 위치에 따라 0.17–0.20으로 움직인다. 3D 도파로나 다른 굴절률 대비에서의 knee 위치. 방사 monitor 없이 잔여로 추정한 방사량의 정확한 값.
증상별 점검표 보기
증상 원인 고치는 법
반사율 과소평가·음수 load_minus_flux_data를 빼먹음 bend run에서 반사 monitor를 만든 직후 호출
R이 음수 뒤로 가는 flux 부호를 안 뒤집음 R = -get_fluxes(refl) / P_in
load_minus_flux_data 배열 크기 오류 두 run의 resolution·cell·monitor 위치 불일치 make_sim 같은 함수로 두 run 생성
투과 T ≈ 0 투과 단면이 세로선(span)으로 빛과 평행 수직 암에서는 size=(w+2, 0) 가로선
스펙트럼 가장자리가 튐 대역이 넓어 가장자리 source power ≈ 0 df를 줄이거나 중심 ±30%만 해석
R이 이상하게 큼 반사 단면이 source 상류, 또는 PML 얇음 반사 단면은 source 하류, dpml ≥ λ/6

6. 확인 · 두 질문에 답해보기

1. 입사장을 빼는 줄을 지우면 반사율은 어떻게 달라질까요?

설명 확인하기

반사 monitor에 입사와 반사 성분이 함께 남습니다. 이때 같은 마이너스 부호로 R을 계산하면 반사율을 과소평가하거나 음수로 얻을 수 있습니다. 이 줄은 필드를 바꾸는 source가 아니므로 투과장의 전파 자체를 바꾸지는 않습니다.

2. L = 1 − T − R가 0.58이면 방사를 정확히 58% 측정한 것일까요?

설명 확인하기

아닙니다. 여기서는 흡수 없는 모델의 잔여를 방사로 해석했습니다. monitor 위치·PML·격자 오차도 잔여에 영향을 주므로 직접 방사 flux 측정과 수렴성 확인 없이는 그 정밀도를 주장할 수 없습니다.

7. 참고 · 전체 코드와 원본 기록

아래 전체 프로그램은 원본 그대로입니다. 실행 환경과 결과 기록을 함께 확인하세요.

bend90.py (클릭해서 펼치기) 
"""Meep Example 05 - Bent waveguide and the radius trade-off (two-run flux normalization).

A dielectric waveguide (eps = 12, width 1) turns a 90 degree corner.
Run 1: straight waveguide  -> input power P_in and the "incident" flux data at the reflection plane.
Run 2: bent waveguide      -> transmitted flux (vertical arm) and reflected flux (incident part subtracted).
T = P_tran / P_in,  R = -P_refl / P_in,  radiation loss = 1 - T - R.
The sharp corner (radius 0) follows the official bend-flux tutorial; then the corner is rounded
with a quarter-ring of radius R and T is swept over R to find where the loss disappears.

Run:  python bend90.py            (~3 min on one core: sharp + radius sweep + convergence)
Out:  00_source.png, 01_layout.png, 02_field.png, 03_spectrum.png, 04_radius_sweep.png,
      05_field_round.png, 06_anim_sharp.gif, 06_anim_round.gif, result.json   (-> ../assets/05/)
"""
import json
import os
import sys
import time

import numpy as np
import matplotlib
matplotlib.use("Agg")
import meep as mp

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from blogfig import (Label, animate_fields, annotated_layout, field_figure, line_figure,   # noqa: E402
                     record_frames, source_figure, spectrum_figure)

OUT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "assets", "05")
os.makedirs(OUT, exist_ok=True)

# ---------------------------------------------------------------- (1) units & parameters
# Dimensionless units as in the official tutorial: 1 length unit = a (think 1 um).
eps_wg = 12.0            # waveguide permittivity (n = sqrt(12) = 3.46)
w = 1.0                  # waveguide width
fcen = 0.15              # center frequency -> wavelength 1/0.15 = 6.67 units
df = 0.1                 # source bandwidth
nfreq = 11               # number of frequencies in the flux monitors

# Physical reading used only for the figures: choose a so that the center wavelength is 1550 nm.
a_nm = 1550 * fcen       # = 232.5 nm per unit  -> waveguide width 233 nm, cell 3.72 um
a_um = a_nm / 1000

RESOLUTION = 25          # pixels per unit -> width = 25 px, wavelength in the guide (1.92) = 48 px
DPML = 1.0               # PML thickness
sx = sy = 16.0           # square cell, PML included

ycen = -4.0              # y of the input (horizontal) arm
xcen = +4.0              # x of the output (vertical) arm  -> corner at (xcen, ycen)
span = mp.Vector3(0, w + 2)   # source / monitor line: core + 1 unit on each side (evanescent tail)


def positions(dpml):
    """Source and monitor planes measured from the PML edge, so a thicker PML keeps them outside it."""
    edge = sx / 2 - dpml
    return {"src_x": -edge + 0.5,          # source: 0.5 outside the left PML
            "refl_x": -edge + 1.5,         # reflection flux plane: downstream of the source
            "tran_straight_x": edge - 0.5,  # transmission plane for the straight reference run
            "tran_bend_y": edge - 0.5}      # transmission plane for the bend run (on the vertical arm)


# ---------------------------------------------------------------- (2) materials & geometry
def make_geometry(bend: bool, radius: float = 0.0):
    """Straight reference (bend=False), sharp corner (radius=0) or rounded corner (radius>0).

    The rounded corner is a quarter ring: outer cylinder (waveguide) minus inner cylinder (air),
    cut down to one quadrant with air blocks; the two arms are drawn last so they stay intact.
    """
    wg = mp.Medium(epsilon=eps_wg)
    air = mp.Medium(epsilon=1.0)
    if not bend:
        return [mp.Block(center=mp.Vector3(0, ycen), size=mp.Vector3(mp.inf, w), material=wg)]
    r = radius
    cx, cy = xcen - r, ycen + r                      # center of the quarter ring
    geom = []
    if r > 0:
        big = r + w / 2 + 1.0
        geom += [mp.Cylinder(radius=r + w / 2, center=mp.Vector3(cx, cy), material=wg),
                 mp.Cylinder(radius=r - w / 2, center=mp.Vector3(cx, cy), material=air)]
        # keep only the lower-right quadrant (x > cx, y < cy)
        geom += [mp.Block(center=mp.Vector3(cx - big / 2, cy), size=mp.Vector3(big, 2 * big), material=air),
                 mp.Block(center=mp.Vector3(cx + big / 2, cy + big / 2), size=mp.Vector3(big, big), material=air)]
    # sharp corner: the arms overlap by w x w so the outer corner is filled (official geometry);
    # rounded corner: the arms stop where the ring begins
    x_end = xcen + w / 2 if r == 0 else xcen - r     # horizontal arm: left PML -> corner / ring
    horizontal = mp.Block(center=mp.Vector3(0.5 * (-sx / 2 + x_end), ycen),
                          size=mp.Vector3(sx / 2 + x_end, w), material=wg)
    y_start = ycen - w / 2 if r == 0 else ycen + r   # vertical arm: corner / ring -> top PML
    vertical = mp.Block(center=mp.Vector3(xcen, 0.5 * (y_start + sy / 2)),
                        size=mp.Vector3(w, sy / 2 - y_start), material=wg)
    return geom + [horizontal, vertical]


# ---------------------------------------------------------------- (3) source
def make_sources(dpml):
    """A plain Ez line source (not an eigenmode source), as in the official tutorial."""
    p = positions(dpml)
    return [mp.Source(mp.GaussianSource(fcen, fwidth=df), component=mp.Ez,
                      center=mp.Vector3(p["src_x"], ycen), size=span)]


# ---------------------------------------------------------------- (4) simulation & boundaries
def make_sim(bend: bool, radius=0.0, resolution=RESOLUTION, dpml=DPML):
    return mp.Simulation(cell_size=mp.Vector3(sx, sy), resolution=resolution,
                         boundary_layers=[mp.PML(dpml)],
                         geometry=make_geometry(bend, radius), sources=make_sources(dpml))


_reference = {}


def reference_run(resolution, dpml):
    """RUN 1 (cached per resolution/PML): straight guide -> P_in and the incident flux data."""
    key = (resolution, dpml)
    if key in _reference:
        return _reference[key]
    p = positions(dpml)
    sim = make_sim(bend=False, resolution=resolution, dpml=dpml)
    # ------------------------------------------------------------ (5) monitors, run 1
    refl = sim.add_flux(fcen, df, nfreq, mp.FluxRegion(center=mp.Vector3(p["refl_x"], ycen), size=span))
    tran0 = sim.add_flux(fcen, df, nfreq, mp.FluxRegion(center=mp.Vector3(p["tran_straight_x"], ycen), size=span))
    # ------------------------------------------------------------ (6) run 1 & stop condition
    sim.run(until_after_sources=mp.stop_when_fields_decayed(
                25, mp.Ez, mp.Vector3(p["tran_straight_x"], ycen), 1e-6))
    _reference[key] = {"P_in": np.array(mp.get_fluxes(tran0)),      # what actually travels down the guide
                       "refl_data": sim.get_flux_data(refl),         # incident fields at the reflection plane
                       "freqs": np.array(mp.get_flux_freqs(tran0))}
    return _reference[key]


def bend_run(radius=0.0, resolution=RESOLUTION, dpml=DPML, figures=False, field_png=None):
    """RUN 2: the bend. Returns T, R, L spectra (fractions of P_in)."""
    ref = reference_run(resolution, dpml)
    p = positions(dpml)
    sim = make_sim(bend=True, radius=radius, resolution=resolution, dpml=dpml)
    # ------------------------------------------------------------ (5) monitors, run 2
    refl = sim.add_flux(fcen, df, nfreq, mp.FluxRegion(center=mp.Vector3(p["refl_x"], ycen), size=span))
    sim.load_minus_flux_data(refl, ref["refl_data"])  # subtract the incident part -> reflection only
    tran = sim.add_flux(fcen, df, nfreq,
                        mp.FluxRegion(center=mp.Vector3(xcen, p["tran_bend_y"]), size=mp.Vector3(w + 2, 0)))
    decay_pt = (xcen, p["tran_bend_y"])
    if figures:
        annotated_layout(
            sim, os.path.join(OUT, "01_layout.png"), dpml=dpml, unit="um", axis_scale=a_um, axis_step=0.5,
            figsize=(7.5, 7.2), pml_xy=(-3.0, -sy / 2 + dpml / 2),
            params_text=(f"a = {a_nm:.1f} nm  (1 Meep unit)\n"
                         f"eps={eps_wg:g}  w={w:g}a={w*a_nm:.1f}nm  dpml={dpml:g}a\n"
                         f"wl={1/fcen:.2f}a={a_nm/fcen:.0f}nm  res={resolution}/a  cell={sx:g}a"),
            params_xy=(-6.6, 6.6), decay_point=decay_pt, decay_text_xy=(4.6, 5.6),
            title="90-deg waveguide bend (eps = 12, w = 1): Ez line source, flux monitors, PML",
            labels=[
                Label("horizontal arm (geometry)", (-1.0, ycen), (-3.5, -1.8), step=2, color="black"),
                Label("vertical arm (geometry)", (xcen - 0.5, 2.0), (-2.5, 3.5), step=2, color="black"),
                Label("Ez line source", (p["src_x"], ycen - 1.6), (-6.3, -6.2), step=3, color="red"),
                Label("flux: reflection (minus incident)", (p["refl_x"], ycen + 1.6), (-6.3, 0.2), step=5, color="blue"),
                Label("flux: transmission", (xcen - 1.5, p["tran_bend_y"]), (0.0, 5.0), step=5, color="blue"),
            ])
    want_field = figures or field_png is not None
    if want_field:
        nonpml = mp.Volume(center=mp.Vector3(), size=mp.Vector3(sx - 2 * dpml, sy - 2 * dpml))
        dft = sim.add_dft_fields([mp.Ez], fcen, 0, 1, where=nonpml)
    # ------------------------------------------------------------ (6) run 2 & stop condition
    sim.run(until_after_sources=mp.stop_when_fields_decayed(25, mp.Ez, mp.Vector3(*decay_pt), 1e-6))
    # ------------------------------------------------------------ (7) post-processing
    T = np.array(mp.get_fluxes(tran)) / ref["P_in"]      # transmitted fraction
    R = -np.array(mp.get_fluxes(refl)) / ref["P_in"]     # backward flux is negative -> flip the sign
    L = 1.0 - T - R                                      # what is left: radiated out at the corner
    if want_field:
        ez = sim.get_dft_array(dft, mp.Ez, 0)
        eps = sim.get_array(vol=nonpml, component=mp.Dielectric)
        extent_um = [v * a_um for v in (-(sx / 2 - dpml), sx / 2 - dpml, -(sy / 2 - dpml), sy / 2 - dpml)]
        field_figure(ez, extent_um, os.path.join(OUT, field_png or "02_field.png"), core_halfwidth=None,
                     eps=eps, wl=round(a_nm / fcen), wl_unit="nm", component="Ez",
                     layout="row", aspect="equal", unit="um")
    return {"T": T, "R": R, "L": L, "freqs": ref["freqs"]}


t_all = time.time()
ic = nfreq // 2

# source waveform and spectrum; the monitor band is fcen +- df/2
src_info = source_figure(fcen, df, os.path.join(OUT, "00_source.png"), mon_fcen=fcen, mon_df=df,
                         wl_scale=a_nm, wl_unit="nm", time_unit="a/c")

# ================================================================ sharp corner (official example)
t0 = time.time()
sharp = bend_run(0.0, figures=True)
wall_sharp = time.time() - t0
wl = 1 / sharp["freqs"]
print(f"sharp: T = {sharp['T'][ic]:.4f}, R = {sharp['R'][ic]:.4f}, radiation loss = {sharp['L'][ic]:.4f}  ({wall_sharp:.0f} s incl. reference)")
print(f"T over band {wl.min():.2f}-{wl.max():.2f}: {sharp['T'].min():.3f} .. {sharp['T'].max():.3f}")
spectrum_figure(wl * a_nm, {"T (transmitted)": sharp["T"], "R (reflected)": sharp["R"], "1 - T - R (radiated)": sharp["L"]},
                os.path.join(OUT, "03_spectrum.png"), unit="nm", mark=1550, mark_label="1550 nm (fcen)")

# ================================================================ radius sweep
radii = [0.0, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 6.0]
sweep = []
for r in radii:
    if r == 0.0:
        res = sharp
    else:
        res = bend_run(r, field_png=("05_field_round.png" if r == 3.0 else None))
    sweep.append({"radius_a": r, "radius_um": r * a_um, "radius_over_wl": r * fcen,
                  "T": float(res["T"][ic]), "R": float(res["R"][ic]), "L": float(res["L"][ic])})
    print(f"radius {r:.1f} a ({r*a_um:.2f} um): T={res['T'][ic]:.4f} R={res['R'][ic]:.4f} L={res['L'][ic]:.4f}")
line_figure([s["radius_um"] for s in sweep],
            {"T (transmitted)": [s["T"] for s in sweep], "R (reflected)": [s["R"] for s in sweep],
             "1 - T - R (radiated)": [s["L"] for s in sweep]},
            os.path.join(OUT, "04_radius_sweep.png"), xlabel=f"bend radius [um]  (a = {a_nm:.1f} nm, wl = 1550 nm)")

# ================================================================ animations: sharp corner vs rounded corner (radius 3a)
# Fresh simulations with the same source; record from before the pulse peak (t0 = 5/df) until the
# pulse has gone from the source to the top monitor along the guide (distance ~ 21 a at n_eff ~ 2.5).
p = positions(DPML)
nonpml = mp.Volume(center=mp.Vector3(), size=mp.Vector3(sx - 2 * DPML, sy - 2 * DPML))
extent_um = [v * a_um for v in (-(sx / 2 - DPML), sx / 2 - DPML, -(sy / 2 - DPML), sy / 2 - DPML)]
for tag, r_anim in (("sharp", 0.0), ("round", 3.0)):
    sim_anim = make_sim(bend=True, radius=r_anim)
    sim_anim.init_sim()
    eps_anim = sim_anim.get_array(vol=nonpml, component=mp.Dielectric)
    frames, times = record_frames(sim_anim, nonpml, mp.Ez, t_start=5.0 / df - 2.0 / df,
                                  t_end=5.0 / df + 21.0 * 2.5 + 10.0, n_frames=60)
    animate_fields(frames, times, extent_um, os.path.join(OUT, f"06_anim_{tag}.gif"), eps=eps_anim,
                   lines=[((p["src_x"] * a_um, (ycen - 1.5) * a_um), (p["src_x"] * a_um, (ycen + 1.5) * a_um), "red", "Ez source"),
                          (((xcen - 1.5) * a_um, p["tran_bend_y"] * a_um), ((xcen + 1.5) * a_um, p["tran_bend_y"] * a_um), "blue", "flux: transmission")],
                   time_unit="a/c", figsize=(5.4, 4.8), title=f"{tag} corner", legend_loc="lower right")

# ================================================================ convergence (sharp corner)
convergence = [{"resolution": RESOLUTION, "dpml": DPML, "T": sweep[0]["T"], "R": sweep[0]["R"], "L": sweep[0]["L"]}]
for res_px, dpml in ((10, 1.0), (40, 1.0), (25, 1.5)):   # change one thing at a time
    t0 = time.time()
    r = bend_run(0.0, resolution=res_px, dpml=dpml)
    convergence.append({"resolution": res_px, "dpml": dpml, "T": float(r["T"][ic]), "R": float(r["R"][ic]),
                        "L": float(r["L"][ic]), "wall_s": time.time() - t0})
    print(f"convergence res={res_px} dpml={dpml}: T={r['T'][ic]:.4f} R={r['R'][ic]:.4f} L={r['L'][ic]:.4f}")

if mp.am_master():
    with open(os.path.join(OUT, "result.json"), "w") as f:
        json.dump({"T": sweep[0]["T"], "R": sweep[0]["R"], "loss": sweep[0]["L"],
                   "a_nm": a_nm, "wavelengths_a": wl.tolist(), "wavelengths_nm": (wl * a_nm).tolist(),
                   "T_spectrum": sharp["T"].tolist(), "R_spectrum": sharp["R"].tolist(),
                   "radius_sweep": sweep, "convergence": convergence, "source": src_info,
                   "wall_s_total": time.time() - t_all, "meep": mp.__version__},
                  f, indent=2)
원본 실행 로그·재현 환경 보기

§4의 발췌 코드와 달리 전체 코드에는 그림 저장·result.json 기록이 들어 있다. 그림 helper blogfig.py(annotated_layout, field_figure, spectrum_figure)는 시리즈 공통이며 같은 폴더(code/)에 있다. 전체 코드와 helper: https://github.com/jin-castle/meep-examples/blob/main/code.

실행 결과 (2026-10-23 재실행):

sharp: T = 0.1997, R = 0.2202, radiation loss = 0.5801  (10 s incl. reference)
T over band 5.00-10.00: 0.169 .. 0.512
radius 0.0 a (0.00 um): T=0.1997 R=0.2202 L=0.5801
radius 0.5 a (0.12 um): T=0.4865 R=0.0518 L=0.4617
radius 1.0 a (0.23 um): T=0.7458 R=0.0014 L=0.2528
radius 1.5 a (0.35 um): T=0.9073 R=0.0009 L=0.0918
radius 2.0 a (0.47 um): T=0.9638 R=0.0005 L=0.0358
radius 3.0 a (0.70 um): T=0.9859 R=0.0003 L=0.0138
radius 4.0 a (0.93 um): T=1.0031 R=0.0001 L=-0.0031
radius 6.0 a (1.40 um): T=0.9995 R=0.0000 L=0.0005
convergence res=10 dpml=1.0: T=0.1983 R=0.2287 L=0.5730
convergence res=40 dpml=1.0: T=0.1894 R=0.2241 L=0.5865
convergence res=25 dpml=1.5: T=0.1703 R=0.2173 L=0.6124

재현 환경: meep 1.33.0 · Python 3.11 · conda install -c conda-forge pymeep · 실행 python bend90.py (약 12 s, 단일 코어)

응용과 다음 학습 주제 보기

어디에 쓰이는가

bend 반지름은 칩 면적을 정하는 숫자다. 반지름을 두 배로 하면 고리 하나의 면적은 네 배가 되고, foundry의 설계 규칙에는 최소 반지름이 적혀 있다.

응용 이 글의 어떤 것을 쓰는가 그 다음에 필요한 것
PIC 배선과 면적(footprint) 반지름–손실 곡선과 knee 09편 역설계 bend
ring resonator·spiral delay line 작은 반지름의 곡률 손실이 Q와 FSR을 정한다 12편 고리
foundry PDK의 최소 bend radius 규칙 knee 1.5~2a가 그 규칙의 근거 —
입력 대비 출력의 모든 측정 2-run 정규화 06편 이후 전부
]]>jin-castle