snapshot 2025-02-07 01:30:37.661917
This commit is contained in:
parent
777ecbc024
commit
d0e3fae4b7
1
_doc_mathimg/gladtex.cache
Normal file
1
_doc_mathimg/gladtex.cache
Normal file
File diff suppressed because one or more lines are too long
61
examples/bend.py
Normal file
61
examples/bend.py
Normal file
@ -0,0 +1,61 @@
|
||||
import numpy
|
||||
from numpy import pi
|
||||
import gridlock
|
||||
from meanas.fdfd import waveguide_2d, waveguide_cyl
|
||||
from matplotlib import pyplot
|
||||
|
||||
|
||||
wl = 1310
|
||||
dx = 10
|
||||
radius = 25e3
|
||||
width = 400
|
||||
thf = 161
|
||||
thp = 77
|
||||
eps_si = 3.51 ** 2
|
||||
eps_ox = 1.453 ** 2
|
||||
|
||||
|
||||
|
||||
x0 = (width / 2) % dx
|
||||
omega = 2 * pi / wl
|
||||
|
||||
grid = gridlock.Grid([
|
||||
numpy.arange(-3000, 3000 + dx, dx),
|
||||
numpy.arange(-1500, 1500 + dx, dx),
|
||||
numpy.arange(-1 * dx, 1 * dx + dx, dx)],
|
||||
periodic=True,
|
||||
)
|
||||
epsilon = grid.allocate(eps_ox)
|
||||
|
||||
grid.draw_cuboid(epsilon, center=[x0, thf / 2, 0], dimensions=[width, thf, 1e6], foreground=eps_si)
|
||||
grid.draw_cuboid(epsilon, center=[x0, thp / 2, 0], dimensions=[width + 3e3, thp, 1e6], foreground=eps_si)
|
||||
grid.draw_cuboid(epsilon, center=[x0 + width / 2 + 2e3, thf / 2, 0], dimensions=[1e3, thf, 1e6], foreground=eps_si)
|
||||
grid.draw_cuboid(epsilon, center=[x0 - width / 2 - 2e3, thf / 2, 0], dimensions=[1e3, thf, 1e6], foreground=eps_si)
|
||||
|
||||
|
||||
tilt = (1 + grid.xyz[0] / radius)
|
||||
se = tilt[None, :, None, None] * epsilon
|
||||
#print(tilt)
|
||||
|
||||
|
||||
dxes = [grid.dxyz, grid.autoshifted_dxyz()]
|
||||
dxes_2d = [[d[0], d[1]] for d in dxes]
|
||||
mode_numbers = numpy.arange(6)
|
||||
args = dict(dxes=dxes_2d, omega=omega, mode_numbers=numpy.arange(6))
|
||||
|
||||
e_xys, wavenumbers = waveguide_2d.solve_modes(epsilon=se[:, :, :, 1].ravel(), **args)
|
||||
ee, hh = waveguide_2d.normalized_fields_e(e_xys[0], wavenumber=wavenumbers[0], dxes=dxes_2d, omega=omega, epsilon=se[:, :, :, 1].ravel())
|
||||
|
||||
#print('tilted baseline:' wavenumbers * wl / pi / 2)
|
||||
|
||||
|
||||
rmin = radius + grid.xyz[0].min()
|
||||
epsv = epsilon[:, :, :, 1].ravel()
|
||||
e2, angular_wavenumbers2 = waveguide_cyl.solve_modes(epsilon=epsv, rmin=rmin, **args)
|
||||
print('cylindrical:', angular_wavenumbers2 * wl / pi / 2 / radius)
|
||||
|
||||
|
||||
wavenumbers_2 = waveguide_cyl.linear_wavenumbers(e_xys=e2, angular_wavenumbers=angular_wavenumbers2, rmin=rmin, epsilon=epsv, dxes=dxes_2d)
|
||||
print('cyl_auto:', wavenumbers_2 * wl / pi / 2)
|
||||
|
||||
|
||||
65
examples/eme.py
Normal file
65
examples/eme.py
Normal file
@ -0,0 +1,65 @@
|
||||
import numpy
|
||||
from numpy import pi
|
||||
import gridlock
|
||||
from gridlock import XYZExtent
|
||||
from meanas.fdfd import waveguide_2d, waveguide_cyl
|
||||
from matplotlib import pyplot
|
||||
|
||||
|
||||
wl = 1310
|
||||
dx = 10
|
||||
radius = 25e3
|
||||
width = 400
|
||||
thf = 161
|
||||
thp = 77
|
||||
eps_si = 3.51 ** 2
|
||||
eps_ox = 1.453 ** 2
|
||||
|
||||
|
||||
|
||||
x0 = (width / 2) % dx
|
||||
omega = 2 * pi / wl
|
||||
|
||||
grid = gridlock.Grid([
|
||||
numpy.arange(-3000, 3000 + dx, dx),
|
||||
numpy.arange(-1500, 1500 + dx, dx),
|
||||
numpy.arange(-5 * dx, 5 * dx + dx, dx)],
|
||||
periodic=True,
|
||||
)
|
||||
epsilon = grid.allocate(eps_ox)
|
||||
|
||||
grid.draw_cuboid(epsilon, extent=XYZExtent(xctr=x0, lx=width + 5e3, ymin=0, ymax=thf, zmin=-1e6, zmax=0), foreground=eps_si)
|
||||
grid.draw_cuboid(epsilon, extent=XYZExtent(xmax=-width / 2, lx=1.5e3, ymin=thp, ymax=1e6, zmin=-1e6, zmax=0), foreground=eps_ox)
|
||||
grid.draw_cuboid(epsilon, extent=XYZExtent(xmin= width / 2, lx=1.5e3, ymin=thp, ymax=1e6, zmin=-1e6, zmax=0), foreground=eps_ox)
|
||||
|
||||
grid.draw_cuboid(epsilon, extent=XYZExtent(xmax=-(width / 2 + 2.5e3), lx=1e3, ymin=0, ymax=thf, zmin=0, zmax=1e6), foreground=eps_si)
|
||||
grid.draw_cuboid(epsilon, extent=XYZExtent(xmax= width / 2 + 2.5e3, lx=1e3, ymin=0, ymax=thf, zmin=0, zmax=1e6), foreground=eps_si)
|
||||
|
||||
|
||||
dxes = [grid.dxyz, grid.autoshifted_dxyz()]
|
||||
dxes_2d = [[d[0], d[1]] for d in dxes]
|
||||
mode_numbers = numpy.arange(20)
|
||||
args = dict(dxes=dxes_2d, omega=omega, mode_numbers=mode_numbers)
|
||||
|
||||
eps1 = epsilon[:, :, :, 1].ravel()
|
||||
eps2 = epsilon[:, :, :, -2].ravel()
|
||||
eL_xys, wavenumbers_L = waveguide_2d.solve_modes(epsilon=eps1, **args)
|
||||
eR_xys, wavenumbers_R = waveguide_2d.solve_modes(epsilon=eps2, **args)
|
||||
eh_L = [
|
||||
waveguide_2d.normalized_fields_e(e_xy, wavenumber=wavenumber, dxes=dxes_2d, omega=omega, epsilon=eps1)
|
||||
for e_xy, wavenumber in zip(eL_xys, wavenumbers_L)]
|
||||
eh_R = [
|
||||
waveguide_2d.normalized_fields_e(e_xy, wavenumber=wavenumber, dxes=dxes_2d, omega=omega, epsilon=eps2)
|
||||
for e_xy, wavenumber in zip(eR_xys, wavenumbers_R)]
|
||||
|
||||
|
||||
eh_R = [
|
||||
waveguide_2d.normalized_fields_e(e_xy, wavenumber=wavenumber, dxes=dxes_2d, omega=omega, epsilon=eps2)
|
||||
for e_xy, wavenumber in zip(eR_xys, wavenumbers_R)]
|
||||
|
||||
|
||||
ss = waveguide_2d.get_s(eh_L, wavenumbers_L, eh_R, wavenumbers_R, dxes=dxes_2d)
|
||||
|
||||
ss11 = waveguide_2d.get_s(eh_L, wavenumbers_L, eh_L, wavenumbers_L, dxes=dxes_2d)
|
||||
ss22 = waveguide_2d.get_s(eh_R, wavenumbers_R, eh_R, wavenumbers_R, dxes=dxes_2d)
|
||||
|
||||
105
examples/eme_bend.py
Normal file
105
examples/eme_bend.py
Normal file
@ -0,0 +1,105 @@
|
||||
import numpy
|
||||
from numpy import pi
|
||||
import gridlock
|
||||
from gridlock import XYZExtent
|
||||
from meanas.fdfd import waveguide_2d, waveguide_cyl
|
||||
from meanas.fdmath import vec, unvec
|
||||
from matplotlib import pyplot, colors
|
||||
from scipy import sparse
|
||||
import skrf
|
||||
from skrf import Network
|
||||
|
||||
|
||||
wl = 1310
|
||||
dx = 10
|
||||
radius = 25e3
|
||||
width = 400
|
||||
thf = 161
|
||||
thp = 77
|
||||
eps_si = 3.51 ** 2
|
||||
eps_ox = 1.453 ** 2
|
||||
|
||||
|
||||
|
||||
x0 = (width / 2) % dx
|
||||
omega = 2 * pi / wl
|
||||
|
||||
grid = gridlock.Grid([
|
||||
numpy.arange(-3000, 3000 + dx, dx),
|
||||
numpy.arange(-1500, 1500 + dx, dx),
|
||||
numpy.arange(-5 * dx, 5 * dx + dx, dx)],
|
||||
periodic=True,
|
||||
)
|
||||
epsilon = grid.allocate(eps_ox)
|
||||
|
||||
grid.draw_cuboid(epsilon, extent=XYZExtent(xctr=x0, lx=width + 5e3, ymin=0, ymax=thf, zmin=-1e6, zmax=0), foreground=eps_si)
|
||||
grid.draw_cuboid(epsilon, extent=XYZExtent(xmax=-width / 2, lx=1.5e3, ymin=thp, ymax=1e6, zmin=-1e6, zctr=0), foreground=eps_ox)
|
||||
grid.draw_cuboid(epsilon, extent=XYZExtent(xmin= width / 2, lx=1.5e3, ymin=thp, ymax=1e6, zmin=-1e6, zctr=0), foreground=eps_ox)
|
||||
|
||||
|
||||
dxes = [grid.dxyz, grid.autoshifted_dxyz()]
|
||||
dxes_2d = [[d[0], d[1]] for d in dxes]
|
||||
mode_numbers = numpy.arange(20)
|
||||
args = dict(dxes=dxes_2d, omega=omega, mode_numbers=mode_numbers)
|
||||
|
||||
eps = epsilon[:, :, :, 2].ravel()
|
||||
rmin = radius + grid.xyz[0].min()
|
||||
eL_xys, wavenumbers_L = waveguide_2d.solve_modes(epsilon=eps, **args)
|
||||
eR_xys, ang_wavenumbers_R = waveguide_cyl.solve_modes(epsilon=eps, **args, rmin=rmin)
|
||||
linear_wavenumbers_R = waveguide_cyl.linear_wavenumbers(e_xys=eR_xys, angular_wavenumbers=ang_wavenumbers_R, rmin=rmin, epsilon=eps, dxes=dxes_2d)
|
||||
|
||||
eh_L = [
|
||||
waveguide_2d.normalized_fields_e(e_xy, wavenumber=wavenumber, dxes=dxes_2d, omega=omega, epsilon=eps)
|
||||
for e_xy, wavenumber in zip(eL_xys, wavenumbers_L)]
|
||||
eh_R = [
|
||||
waveguide_cyl.normalized_fields_e(e_xy, angular_wavenumber=ang_wavenumber, dxes=dxes_2d, omega=omega, epsilon=eps, rmin=rmin)
|
||||
for e_xy, ang_wavenumber in zip(eR_xys, ang_wavenumbers_R)]
|
||||
|
||||
|
||||
ss = waveguide_2d.get_s(eh_L, wavenumbers_L, eh_R, linear_wavenumbers_R, dxes=dxes_2d)
|
||||
|
||||
ss11 = waveguide_2d.get_s(eh_L, wavenumbers_L, eh_L, wavenumbers_L, dxes=dxes_2d)
|
||||
ss22 = waveguide_2d.get_s(eh_R, linear_wavenumbers_R, eh_R, linear_wavenumbers_R, dxes=dxes_2d)
|
||||
|
||||
|
||||
fig, axes = pyplot.subplots(2, 2)
|
||||
mb0 = axes[0, 0].pcolormesh(numpy.abs(ss[::-1])**2, cmap='hot', vmin=0)
|
||||
fig.colorbar(mb0)
|
||||
axes[1, 0].set_title('S Abs^2')
|
||||
mb2 = axes[1, 0].pcolormesh(ss[::-1].real, cmap='bwr', norm=colors.CenteredNorm())
|
||||
fig.colorbar(mb2)
|
||||
axes[1, 0].set_title('S Real')
|
||||
mb3 = axes[1, 1].pcolormesh(ss[::-1].imag, cmap='bwr', norm=colors.CenteredNorm())
|
||||
fig.colorbar(mb3)
|
||||
axes[1, 1].set_title('S Imag')
|
||||
pyplot.show(block=False)
|
||||
|
||||
e1, h1 = eh_L[2]
|
||||
e2, h2 = eh_R[2]
|
||||
|
||||
figE, axesE = pyplot.subplots(3, 2)
|
||||
figH, axesH = pyplot.subplots(3, 2)
|
||||
esqmax = max(numpy.abs(e1).max(), numpy.abs(e2).max()) ** 2
|
||||
hsqmax = max(numpy.abs(h1).max(), numpy.abs(h2).max()) ** 2
|
||||
for mm, (ee, hh) in enumerate(zip((e1, e2), (h1, h2))):
|
||||
E = unvec(ee, grid.shape[:2])
|
||||
H = unvec(hh, grid.shape[:2])
|
||||
for aa in range(3):
|
||||
axesE[aa, mm].pcolormesh((numpy.abs(E[aa]) ** 2).T, cmap='bwr', norm=colors.CenteredNorm(halfrange=esqmax))
|
||||
axesH[aa, mm].pcolormesh((numpy.abs(H[aa]) ** 2).T, cmap='bwr', norm=colors.CenteredNorm(halfrange=hsqmax))
|
||||
pyplot.show(block=False)
|
||||
|
||||
|
||||
|
||||
net_wb = Network(f=[1 / wl], s = ss)
|
||||
net_bw = net_wb.copy()
|
||||
net_bw.renumber(numpy.arange(40), numpy.roll(numpy.arange(40), 20))
|
||||
|
||||
wg_phase = sparse.diags_array(numpy.exp(-1j * wavenumbers_L * 100e3))
|
||||
bend_phase = sparse.diags_array(numpy.exp(-1j * ang_wavenumbers_R * pi / 2))
|
||||
net_propwg = Network(f=[1 / wl], s = sparse.block_array(([None, wg_phase], [wg_phase, None])).toarray()[None, ...])
|
||||
net_propbend = Network(f=[1 / wl], s = sparse.block_array(([None, bend_phase], [bend_phase, None])).toarray()[None, ...])
|
||||
|
||||
|
||||
cir = skrf.network.cascade_list([net_propwg, net_wb, net_propbend, net_bw, net_propwg])
|
||||
|
||||
168
examples/fdtd.py
168
examples/fdtd.py
@ -6,13 +6,20 @@ See main() for simulation setup.
|
||||
|
||||
import sys
|
||||
import time
|
||||
import copy
|
||||
|
||||
import numpy
|
||||
import h5py
|
||||
from numpy.linalg import norm
|
||||
|
||||
from meanas import fdtd
|
||||
from meanas.fdtd import cpml_params, updates_with_cpml
|
||||
from masque import Pattern, shapes
|
||||
from meanas.fdtd.misc import gaussian_packet
|
||||
|
||||
from meanas.fdfd.operators import e_full
|
||||
from meanas.fdfd.scpml import stretch_with_scpml
|
||||
from meanas.fdmath import vec
|
||||
from masque import Pattern, Circle, Polygon
|
||||
import gridlock
|
||||
import pcgen
|
||||
|
||||
@ -41,50 +48,51 @@ def perturbed_l3(a: float, radius: float, **kwargs) -> Pattern:
|
||||
`masque.Pattern` object containing the L3 design
|
||||
"""
|
||||
|
||||
default_args = {'hole_dose': 1,
|
||||
'trench_dose': 1,
|
||||
'hole_layer': 0,
|
||||
'trench_layer': 1,
|
||||
'shifts_a': (0.15, 0, 0.075),
|
||||
'shifts_r': (1.0, 1.0, 1.0),
|
||||
'xy_size': (10, 10),
|
||||
'perturbed_radius': 1.1,
|
||||
'trench_width': 1.2e3,
|
||||
}
|
||||
default_args = {
|
||||
'hole_layer': 0,
|
||||
'trench_layer': 1,
|
||||
'shifts_a': (0.15, 0, 0.075),
|
||||
'shifts_r': (1.0, 1.0, 1.0),
|
||||
'xy_size': (10, 10),
|
||||
'perturbed_radius': 1.1,
|
||||
'trench_width': 1.2e3,
|
||||
}
|
||||
kwargs = {**default_args, **kwargs}
|
||||
|
||||
xyr = pcgen.l3_shift_perturbed_defect(mirror_dims=kwargs['xy_size'],
|
||||
perturbed_radius=kwargs['perturbed_radius'],
|
||||
shifts_a=kwargs['shifts_a'],
|
||||
shifts_r=kwargs['shifts_r'])
|
||||
xyr = pcgen.l3_shift_perturbed_defect(
|
||||
mirror_dims=kwargs['xy_size'],
|
||||
perturbed_radius=kwargs['perturbed_radius'],
|
||||
shifts_a=kwargs['shifts_a'],
|
||||
shifts_r=kwargs['shifts_r'],
|
||||
)
|
||||
xyr *= a
|
||||
xyr[:, 2] *= radius
|
||||
|
||||
pat = Pattern()
|
||||
pat.name = f'L3p-a{a:g}r{radius:g}rp{kwargs["perturbed_radius"]:g}'
|
||||
pat.shapes += [shapes.Circle(radius=r, offset=(x, y),
|
||||
dose=kwargs['hole_dose'],
|
||||
layer=kwargs['hole_layer'])
|
||||
for x, y, r in xyr]
|
||||
#pat.name = f'L3p-a{a:g}r{radius:g}rp{kwargs["perturbed_radius"]:g}'
|
||||
pat.shapes[(kwargs['hole_layer'], 0)] += [
|
||||
Circle(radius=r, offset=(x, y))
|
||||
for x, y, r in xyr]
|
||||
|
||||
maxes = numpy.max(numpy.fabs(xyr), axis=0)
|
||||
pat.shapes += [shapes.Polygon.rectangle(
|
||||
lx=(2 * maxes[0]), ly=kwargs['trench_width'],
|
||||
offset=(0, s * (maxes[1] + a + kwargs['trench_width'] / 2)),
|
||||
dose=kwargs['trench_dose'], layer=kwargs['trench_layer'])
|
||||
for s in (-1, 1)]
|
||||
pat.shapes[(kwargs['trench_layer'], 0)] += [
|
||||
Polygon.rectangle(
|
||||
lx=(2 * maxes[0]), ly=kwargs['trench_width'],
|
||||
offset=(0, s * (maxes[1] + a + kwargs['trench_width'] / 2))
|
||||
)
|
||||
for s in (-1, 1)]
|
||||
return pat
|
||||
|
||||
|
||||
def main():
|
||||
dtype = numpy.float32
|
||||
max_t = 8000 # number of timesteps
|
||||
max_t = 3600 # number of timesteps
|
||||
|
||||
dx = 40 # discretization (nm/cell)
|
||||
pml_thickness = 8 # (number of cells)
|
||||
|
||||
wl = 1550 # Excitation wavelength and fwhm
|
||||
dwl = 200
|
||||
dwl = 100
|
||||
|
||||
# Device design parameters
|
||||
xy_size = numpy.array([10, 10])
|
||||
@ -107,69 +115,89 @@ def main():
|
||||
|
||||
# #### Create the grid, mask, and draw the device ####
|
||||
grid = gridlock.Grid(edge_coords)
|
||||
epsilon = grid.allocate(n_air**2, dtype=dtype)
|
||||
grid.draw_slab(epsilon,
|
||||
surface_normal=2,
|
||||
center=[0, 0, 0],
|
||||
thickness=th,
|
||||
eps=n_slab**2)
|
||||
epsilon = grid.allocate(n_air ** 2, dtype=dtype)
|
||||
grid.draw_slab(
|
||||
epsilon,
|
||||
slab = dict(axis='z', center=0, span=th),
|
||||
foreground = n_slab ** 2,
|
||||
)
|
||||
|
||||
mask = perturbed_l3(a, r)
|
||||
grid.draw_polygons(
|
||||
epsilon,
|
||||
slab = dict(axis='z', center=0, span=2 * th),
|
||||
foreground = n_air ** 2,
|
||||
offset2d = (0, 0),
|
||||
polygons = mask.as_polygons(library=None),
|
||||
)
|
||||
|
||||
grid.draw_polygons(epsilon,
|
||||
surface_normal=2,
|
||||
center=[0, 0, 0],
|
||||
thickness=2 * th,
|
||||
eps=n_air**2,
|
||||
polygons=mask.as_polygons())
|
||||
print(f'{grid.shape=}')
|
||||
|
||||
print(grid.shape)
|
||||
|
||||
dt = .99/numpy.sqrt(3)
|
||||
e = [numpy.zeros_like(epsilon[0], dtype=dtype) for _ in range(3)]
|
||||
h = [numpy.zeros_like(epsilon[0], dtype=dtype) for _ in range(3)]
|
||||
dt = dx * 0.99 / numpy.sqrt(3)
|
||||
ee = numpy.zeros_like(epsilon, dtype=dtype)
|
||||
hh = numpy.zeros_like(epsilon, dtype=dtype)
|
||||
|
||||
dxes = [grid.dxyz, grid.autoshifted_dxyz()]
|
||||
|
||||
# PMLs in every direction
|
||||
pml_params = [[cpml_params(axis=dd, polarity=pp, dt=dt,
|
||||
thickness=pml_thickness, epsilon_eff=1.0**2)
|
||||
for pp in (-1, +1)]
|
||||
for dd in range(3)]
|
||||
update_E, update_H = updates_with_cpml(cpml_params=pml_params, dt=dt,
|
||||
dxes=dxes, epsilon=epsilon)
|
||||
pml_params = [
|
||||
[cpml_params(axis=dd, polarity=pp, dt=dt, thickness=pml_thickness, epsilon_eff=n_air ** 2)
|
||||
for pp in (-1, +1)]
|
||||
for dd in range(3)]
|
||||
update_E, update_H = updates_with_cpml(cpml_params=pml_params, dt=dt, dxes=dxes, epsilon=epsilon)
|
||||
|
||||
# sample_interval = numpy.floor(1 / (2 * 1 / wl * dt)).astype(int)
|
||||
# print(f'Save time interval would be {sample_interval} * dt = {sample_interval * dt:3g}')
|
||||
|
||||
|
||||
# Source parameters and function
|
||||
w = 2 * numpy.pi * dx / wl
|
||||
fwhm = dwl * w * w / (2 * numpy.pi * dx)
|
||||
alpha = (fwhm ** 2) / 8 * numpy.log(2)
|
||||
delay = 7/numpy.sqrt(2 * alpha)
|
||||
source_phasor, _delay = gaussian_packet(wl=wl, dwl=100, dt=dt, turn_on=1e-5)
|
||||
aa, cc, ss = source_phasor(numpy.arange(max_t))
|
||||
srca_real = aa * cc
|
||||
src_maxt = numpy.argwhere(numpy.diff(aa < 1e-5))[-1]
|
||||
assert aa[src_maxt - 1] >= 1e-5
|
||||
phasor_norm = dt / (aa * cc * cc).sum()
|
||||
|
||||
def field_source(i):
|
||||
t0 = i * dt - delay
|
||||
return numpy.sin(w * t0) * numpy.exp(-alpha * t0**2)
|
||||
Jph = numpy.zeros_like(epsilon, dtype=complex)
|
||||
Jph[1, *(grid.shape // 2)] = epsilon[1, *(grid.shape // 2)]
|
||||
Eph = numpy.zeros_like(Jph)
|
||||
|
||||
# #### Run a bunch of iterations ####
|
||||
output_file = h5py.File('simulation_output.h5', 'w')
|
||||
start = time.perf_counter()
|
||||
for t in range(max_t):
|
||||
update_E(e, h, epsilon)
|
||||
for tt in range(max_t):
|
||||
update_E(ee, hh, epsilon)
|
||||
|
||||
e[1][tuple(grid.shape//2)] += field_source(t)
|
||||
update_H(e, h)
|
||||
if tt < src_maxt:
|
||||
ee[1, *(grid.shape // 2)] -= srca_real[tt]
|
||||
update_H(ee, hh)
|
||||
|
||||
avg_rate = (t + 1)/(time.perf_counter() - start))
|
||||
print(f'iteration {t}: average {avg_rate} iterations per sec')
|
||||
avg_rate = (tt + 1) / (time.perf_counter() - start)
|
||||
sys.stdout.flush()
|
||||
|
||||
if t % 20 == 0:
|
||||
r = sum([(f * f * e).sum() for f, e in zip(e, epsilon)])
|
||||
print('E sum', r)
|
||||
if tt % 200 == 0:
|
||||
print(f'iteration {tt}: average {avg_rate} iterations per sec')
|
||||
E_energy_sum = (ee * ee * epsilon).sum()
|
||||
print(f'{E_energy_sum=}')
|
||||
|
||||
# Save field slices
|
||||
if (t % 20 == 0 and (max_t - t <= 1000 or t <= 2000)) or t == max_t-1:
|
||||
print('saving E-field')
|
||||
for j, f in enumerate(e):
|
||||
output_file['/E{}_t{}'.format('xyz'[j], t)] = f[:, :, round(f.shape[2]/2)]
|
||||
if (tt % 20 == 0 and (max_t - tt <= 1000 or tt <= 2000)) or tt == max_t - 1:
|
||||
print(f'saving E-field at iteration {tt}')
|
||||
output_file[f'/E_t{tt}'] = ee[:, :, :, ee.shape[3] // 2]
|
||||
|
||||
Eph += (cc[tt] - 1j * ss[tt]) * phasor_norm * ee
|
||||
|
||||
omega = 2 * pi / wl
|
||||
Eph *= numpy.exp(-1j * dt / 2 * omega)
|
||||
b = -1j * omega * Jph
|
||||
dxes_fdfd = copy.deepcopy(dxes)
|
||||
for pp in (-1, +1):
|
||||
for dd in range(3):
|
||||
stretch_with_scpml(dxes_fdfd, axis=dd, polarity=pp, omega=omega, epsilon_effective=n_air ** 2, thickness=pml_thickness)
|
||||
A = e_full(omega=omega, dxes=dxes, epsilon=epsilon)
|
||||
residual = norm(A @ vec(ee) - vec(b)) / norm(vec(b))
|
||||
print(f'FDFD residual is {residual}')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
|
||||
284
examples/nom.py
Normal file
284
examples/nom.py
Normal file
@ -0,0 +1,284 @@
|
||||
|
||||
from simphony.elements import Model
|
||||
from simphony.netlist import Subcircuit
|
||||
from simphony.simulation import SweepSimulation
|
||||
|
||||
from matplotlib import pyplot as plt
|
||||
|
||||
|
||||
class PeriodicLayer(Model):
|
||||
def __init__(self, left_modes, right_modes, s_params):
|
||||
self.left_modes = left_modes
|
||||
self.right_modes = right_modes
|
||||
self.left_ports = len(self.left_modes)
|
||||
self.right_ports = len(self.right_modes)
|
||||
self.normalize_fields()
|
||||
self.s_params = s_params
|
||||
|
||||
def normalize_fields(self):
|
||||
for mode in range(len(self.left_modes)):
|
||||
self.left_modes[mode].normalize()
|
||||
for mode in range(len(self.right_modes)):
|
||||
self.right_modes[mode].normalize()
|
||||
|
||||
|
||||
class PeriodicEME:
|
||||
def __init__(self, layers=[], num_periods=1):
|
||||
self.layers = layers
|
||||
self.num_periods = num_periods
|
||||
self.wavelength = wavelength
|
||||
|
||||
def propagate(self):
|
||||
wl = self.wavelength
|
||||
if not len(self.layers):
|
||||
raise Exception("Must place layers before propagating")
|
||||
|
||||
num_modes = max([l.num_modes for l in self.layers])
|
||||
iface = InterfaceSingleMode if num_modes == 1 else InterfaceMultiMode
|
||||
|
||||
eme = EME(layers=self.layers)
|
||||
left, right = eme.propagate()
|
||||
self.single_period = eme.s_matrix
|
||||
|
||||
period_layer = PeriodicLayer(left.modes, right.modes, self.single_period)
|
||||
current_layer = PeriodicLayer(left.modes, right.modes, self.single_period)
|
||||
interface = iface(right, left)
|
||||
|
||||
for _ in range(self.num_periods - 1):
|
||||
current_layer.s_params = cascade(current_layer, interface, wl)
|
||||
current_layer.s_params = cascade(current_layer, period_layer, wl)
|
||||
|
||||
self.s_params = current_layer.s_params
|
||||
|
||||
|
||||
class EME:
|
||||
def __init__(self, layers=[]):
|
||||
self.layers = layers
|
||||
self.wavelength = None
|
||||
|
||||
def propagate(self):
|
||||
layers = self.layers
|
||||
wl = layers[0].wavelength if self.wavelength is None else self.wavelength
|
||||
if not len(layers):
|
||||
raise Exception("Must place layers before propagating")
|
||||
|
||||
num_modes = max([l.num_modes for l in layers])
|
||||
iface = InterfaceSingleMode if num_modes == 1 else InterfaceMultiMode
|
||||
|
||||
first_layer = layers[0]
|
||||
current = Current(wl, first_layer)
|
||||
interface = iface(first_layer, layers[1])
|
||||
|
||||
current.s = cascade(current, interface, wl)
|
||||
current.right_pins = interface.right_pins
|
||||
|
||||
for index in range(1, len(layers) - 1):
|
||||
layer1 = layers[index]
|
||||
layer2 = layers[index + 1]
|
||||
interface = iface(layer1, layer2)
|
||||
|
||||
current.s = cascade(current, layer1, wl)
|
||||
current.right_pins = layer1.right_pins
|
||||
|
||||
current.s = cascade(current, interface, wl)
|
||||
current.right_pins = interface.right_pins
|
||||
|
||||
last_layer = layers[-1]
|
||||
current.s = cascade(current, last_layer, wl)
|
||||
current.right_pins = last_layer.right_pins
|
||||
|
||||
self.s_matrix = current.s
|
||||
return first_layer, last_layer
|
||||
|
||||
|
||||
def stack(sa, sb):
|
||||
qab = numpy.eye() - sa.r11 @ sb.r11
|
||||
qba = numpy.eye() - sa.r11 @ sb.r11
|
||||
#s.t12 = sa.t12 @ numpy.pinv(qab) @ sb.t12
|
||||
#s.r21 = sa.t12 @ numpy.pinv(qab) @ sb.r22 @ sa.t21 + sa.r22
|
||||
#s.r12 = sb.t21 @ numpy.pinv(qba) @ sa.r11 @ sb.t12 + sb.r11
|
||||
#s.t21 = sb.t21 @ numpy.pinv(qba) @ sa.t21
|
||||
s.t12 = sa.t12 @ numpy.linalg.solve(qab, sb.t12)
|
||||
s.r21 = sa.t12 @ numpy.linalg.solve(qab, sb.r22 @ sa.t21) + sa.r22
|
||||
s.r12 = sb.t21 @ numpy.linalg.solve(qba, sa.r11 @ sb.t12) + sb.r11
|
||||
s.t21 = sb.t21 @ numpy.linalg.solve(qba, sa.t21)
|
||||
return s
|
||||
|
||||
|
||||
def cascade(first, second, wavelength):
|
||||
circuit = Subcircuit("Device")
|
||||
|
||||
circuit.add([(first, "first"), (second, "second")])
|
||||
for port in range(first.right_ports):
|
||||
circuit.connect("first", "right" + str(port), "second", "left" + str(port))
|
||||
|
||||
simulation = SweepSimulation(circuit, wavelength, wavelength, num=1)
|
||||
result = simulation.simulate()
|
||||
return result.s
|
||||
|
||||
|
||||
class InterfaceSingleMode(Model):
|
||||
def __init__(self, layer1, layer2, num_modes=1):
|
||||
self.num_modes = num_modes
|
||||
self.num_ports = 2 * num_modes
|
||||
self.s = self.solve(layer1, layer2, num_modes)
|
||||
|
||||
def solve(self, layer1, layer2, num_modes):
|
||||
nm = num_modes
|
||||
s = numpy.zeros((2 * nm, 2 * nm), dtype=complex)
|
||||
|
||||
for ii, left_mode in enumerate(layer1.modes):
|
||||
for oo, right_mode in enumerate(layer2.modes):
|
||||
r, t = get_rt(left_mode, right_mode)
|
||||
s[ oo, ii] = r
|
||||
s[nm + oo, ii] = t
|
||||
|
||||
for ii, right_mode in enumerate(layer2.modes):
|
||||
for oo, left_mode in enumerate(layer1.modes):
|
||||
r, t = get_rt(right_mode, left_mode)
|
||||
s[ oo, nm + ii] = t
|
||||
s[nm + oo, nm + ii] = r
|
||||
return s
|
||||
|
||||
|
||||
class InterfaceMultiMode(Model):
|
||||
def __init__(self, layer1, layer2):
|
||||
self.s = self.solve(layer1, layer2)
|
||||
|
||||
def solve(self, layer1, layer2):
|
||||
n1p = layer1.num_modes
|
||||
n2p = layer2.num_modes
|
||||
num_ports = n1p + n2p
|
||||
s = numpy.zeros((num_ports, num_ports), dtype=complex)
|
||||
|
||||
for l1p in range(n1p):
|
||||
ts = get_t(l1p, layer1, layer2)
|
||||
rs = get_r(l1p, layer1, layer2, ts)
|
||||
s[n1p:, l1p] = ts
|
||||
s[:n1p, l1p] = rs
|
||||
|
||||
for l2p in range(n2p):
|
||||
ts = get_t(l2p, layer2, layer1)
|
||||
rs = get_r(l2p, layer2, layer1, ts)
|
||||
s[:n1p, n1p + l2p] = ts
|
||||
s[n1p:, n1p + l2p] = rs
|
||||
|
||||
return s
|
||||
|
||||
|
||||
def get_t(p, left, right):
|
||||
A = numpy.empty(left.shape[0], right.shape[0], dtype=complex)
|
||||
for ll in range(left.shape[0]):
|
||||
for rr in range(right.shape[0]):
|
||||
# TODO optimize loop?
|
||||
A[i, k] = inner_product(right[rr], left[ll]) + inner_product(left[ll], right[rr])
|
||||
|
||||
b = numpy.zeros(left.shape[0i])
|
||||
b[p] = 2 * inner_product(left[p], left[p])
|
||||
|
||||
x = numpy.linalg.solve(A, b)
|
||||
# NOTE: `A` does not depend on `p`, so it might make sense to partially precompute
|
||||
# the solution (pinv(A), or LU decomposition?)
|
||||
# Actually solve() can take multiple vectors, so just pass it something with the full diagonal?
|
||||
|
||||
xx = numpy.matmul(numpy.linalg.pinv(A), b) #TODO verify
|
||||
assert(numpy.allclose(xx, x))
|
||||
return x
|
||||
|
||||
|
||||
def get_r(p, left, right, t):
|
||||
r = numpy.empty(left.num_modes, dtype=complex)
|
||||
for ii in range(left.num_modes):
|
||||
r[ii] = sum((inner_product(right[kk], left[ii]) - inner_product(left[ii], right[kk])) * t[kk]
|
||||
for kk in range(right.num_modes)
|
||||
) / (2 * inner_product(left[ii], left[ii]))
|
||||
return r
|
||||
|
||||
|
||||
def get_rt(left, right):
|
||||
s = 0.5 * (inner_product(left, right) + inner_product(right, left))
|
||||
d = 0.5 * (inner_product(left, right) - inner_product(right, left))
|
||||
t = (s * s - d * d) / s
|
||||
r = 1 - t / (s + d)
|
||||
return -r, t
|
||||
|
||||
|
||||
def inner_product(left_E, right_H, dxes):
|
||||
cross_z = left_E[0] * right_H.conj()[1] - left_E[1] * right_H[0].conj()
|
||||
# cross_z = numpy.cross(left_E, numpy.conj(right_H), axisa=0, axisb=0, axisc=0)[2]
|
||||
return numpy.trapz(numpy.trapz(cross_z, dxes[0][0]), dxes[0][1]) / 2 # TODO might need cumsum on dxes
|
||||
|
||||
|
||||
def propagation_matrix(self, modes, wavelength, distance):
|
||||
eigenv = numpy.array([mode.neff for mode in modes]) * 2 * numpy.pi / wavelength
|
||||
prop_diag = numpy.diag(numpy.exp(distance * 1j * numpy.hstack((eigenv, eigenv))))
|
||||
prop_matrix = numpy.roll(prop_diag, len(eigenv), axis=0)
|
||||
return prop_matrix
|
||||
|
||||
|
||||
def connect_s(A: numpy.ndarray, k: int, B: numpy.ndarray, l: int):
|
||||
"""
|
||||
TODO
|
||||
connect two n-port networks' s-matrices together.
|
||||
specifically, connect port `k` on network `A` to port `l` on network
|
||||
`B`. The resultant network has nports = (A.rank + B.rank-2).
|
||||
|
||||
Args:
|
||||
A: S-parameter matrix of `A`, shape is fxnxn
|
||||
k: port index on `A` (port indices start from 0)
|
||||
B: S-parameter matrix of `B`, shape is fxnxn
|
||||
l: port index on `B`
|
||||
|
||||
Returns:
|
||||
C: new S-parameter matrix
|
||||
"""
|
||||
if k > A.shape[-1] - 1 or l > B.shape[-1] - 1:
|
||||
raise (ValueError("port indices are out of range"))
|
||||
|
||||
C = scipy.sparse.block_diag((A, B), dtype=complex)
|
||||
return innerconnect_s(C, k, A.shape[0] + l)
|
||||
|
||||
|
||||
def innerconnect_s(A, k, l):
|
||||
"""
|
||||
TODO
|
||||
n x n x freq
|
||||
connect two ports of a single n-port network's s-matrix.
|
||||
Specifically, connect port `k` to port `l` on `A`. This results in
|
||||
a (n-2)-port network.
|
||||
|
||||
Args:
|
||||
A: S-parameter matrix of `A`, shape is fxnxn
|
||||
k: port index on `A` (port indices start from 0)
|
||||
l: port index on `A`
|
||||
|
||||
Returns:
|
||||
C: new S-parameter matrix
|
||||
|
||||
Notes:
|
||||
Relevant papers:
|
||||
- Compton, R.C.; , "Perspectives in microwave circuit analysis," Circuits and Systems, 1989., Proceedings of the 32nd Midwest Symposium on , vol., no., pp.716-718 vol.2, 14-16 Aug 1989. URL: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=101955&isnumber=3167
|
||||
- Filipsson, Gunnar; , "A New General Computer Algorithm for S-Matrix Calculation of Interconnected Multiports," Microwave Conference, 1981. 11th European , vol., no., pp.700-704, 7-11 Sept. 1981. URL: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=4131699&isnumber=4131585
|
||||
"""
|
||||
if k > A.shape[-1] - 1 or l > A.shape[-1] - 1:
|
||||
raise (ValueError("port indices are out of range"))
|
||||
|
||||
l = [l]
|
||||
k = [k]
|
||||
|
||||
mkl = 1 - A[k, l]
|
||||
mlk = 1 - A[l, k]
|
||||
C = A + (A[k, :] * A[:, l] * mlk
|
||||
+ A[l, :] * A[:, k] * mkk
|
||||
+ A[k, :] * A[l, l] * A[:, k]
|
||||
+ A[l, :] * A[k, k] * A[:, l]
|
||||
) / (
|
||||
mlk * mkl - A[k, k] * A[l, l]
|
||||
)
|
||||
|
||||
# remove connected ports
|
||||
C = npy.delete(C, (k, l), 1)
|
||||
C = npy.delete(C, (k, l), 2)
|
||||
|
||||
return C
|
||||
|
||||
@ -433,8 +433,11 @@ def _normalized_fields(
|
||||
|
||||
norm_factor = sign * norm_amplitude * numpy.exp(1j * norm_angle)
|
||||
|
||||
print('\nAAA\n', inner_product(e, h, dxes, prop_phase=prop_phase))
|
||||
e *= norm_factor
|
||||
h *= norm_factor
|
||||
print(f'{sign=} {norm_amplitude=} {norm_angle=} {prop_phase=}')
|
||||
print(inner_product(e, h, dxes, prop_phase=prop_phase))
|
||||
|
||||
return e, h
|
||||
|
||||
@ -954,5 +957,3 @@ def inner_product( # TODO documentation
|
||||
Sz_b = E1[1] * H2[0] * dxes_real[0][0][:, None] * dxes_real[1][1][None, :]
|
||||
Sz = 0.5 * (Sz_a.sum() - Sz_b.sum())
|
||||
return Sz
|
||||
|
||||
|
||||
|
||||
130
meanas/fdtd/misc.py
Normal file
130
meanas/fdtd/misc.py
Normal file
@ -0,0 +1,130 @@
|
||||
from typing import Callable
|
||||
from collections.abc import Sequence
|
||||
import logging
|
||||
|
||||
import numpy
|
||||
from numpy.typing import NDArray, ArrayLike
|
||||
from numpy import pi
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
pulse_fn_t = Callable[[int | NDArray], tuple[float, float, float]]
|
||||
|
||||
|
||||
def gaussian_packet(
|
||||
wl: float,
|
||||
dwl: float,
|
||||
dt: float,
|
||||
turn_on: float = 1e-10,
|
||||
one_sided: bool = False,
|
||||
) -> tuple[pulse_fn_t, float]:
|
||||
"""
|
||||
Gaussian pulse (or gaussian ramp) for FDTD excitation
|
||||
|
||||
exp(-a*t*t) ==> exp(-omega * omega / (4 * a)) [fourier, ignoring leading const.]
|
||||
|
||||
FWHM_time is 2 * sqrt(2 * log(2)) * sqrt(2 / a)
|
||||
FWHM_omega is 2 * sqrt(2 * log(2)) * sqrt(2 * a) = 4 * sqrt(log(2) * a)
|
||||
|
||||
"""
|
||||
# dt * dw = 4 * ln(2)
|
||||
|
||||
omega = 2 * pi / wl
|
||||
freq = 1 / wl
|
||||
fwhm_omega = dwl * omega * omega / (2 * pi) # dwl -> d_omega (approx)
|
||||
alpha = (fwhm_omega * fwhm_omega) * numpy.log(2) / 8
|
||||
delay = numpy.sqrt(-numpy.log(turn_on) / alpha)
|
||||
delay = numpy.ceil(delay * freq) / freq # force delay to integer number of periods to maintain phase
|
||||
logger.info(f'src_time {2 * delay / dt}')
|
||||
|
||||
def source_phasor(ii: int | NDArray) -> tuple[float, float, float]:
|
||||
t0 = ii * dt - delay
|
||||
envelope = numpy.sqrt(numpy.sqrt(2 * alpha / pi)) * numpy.exp(-alpha * t0 * t0)
|
||||
|
||||
if one_sided and t0 > 0:
|
||||
envelope = 1
|
||||
|
||||
cc = numpy.cos(omega * t0)
|
||||
ss = numpy.sin(omega * t0)
|
||||
|
||||
return envelope, cc, ss
|
||||
|
||||
# nrm = numpy.exp(-omega * omega / alpha) / 2
|
||||
|
||||
return source_phasor, delay
|
||||
|
||||
|
||||
def ricker_pulse(
|
||||
wl: float,
|
||||
dt: float,
|
||||
turn_on: float = 1e-10,
|
||||
) -> tuple[pulse_fn_t, float]:
|
||||
"""
|
||||
Ricker wavelet (second derivative of a gaussian pulse)
|
||||
|
||||
t0 = ii * dt - delay
|
||||
R = w_peak * t0 / 2
|
||||
f(t) = (1 - 2 * (pi * f_peak * t0) ** 2) * exp(-(pi * f_peak * t0)**2
|
||||
= (1 - (w_peak * t0)**2 / 2 exp(-(w_peak * t0 / 2) **2)
|
||||
= (1 - 2 * R * R) * exp(-R * R)
|
||||
|
||||
# NOTE: don't use cosine/sine for J, just for phasor readout
|
||||
"""
|
||||
omega = 2 * pi / wl
|
||||
freq = 1 / wl
|
||||
r0 = omega / 2
|
||||
|
||||
from scipy.optimize import root_scalar
|
||||
delay_results = root_scalar(lambda xx: (1 - omega * omega * tt * tt / 2) * numpy.exp(-omega * omega / 4 * tt * tt) - turn_on, x0=0, x1=-2 / omega)
|
||||
delay = delay_results.root
|
||||
delay = numpy.ceil(delay * freq) / freq # force delay to integer number of periods to maintain phase
|
||||
|
||||
def source_phasor(ii: int | NDArray) -> tuple[float, float, float]:
|
||||
t0 = ii * dt - delay
|
||||
rr = omega * t0 / 2
|
||||
ff = (1 - 2 * rr * rr) * numpy.exp(-rr * rr)
|
||||
|
||||
cc = numpy.cos(omega * t0)
|
||||
ss = numpy.sin(omega * t0)
|
||||
|
||||
return ff, cc, ss
|
||||
|
||||
return source_phasor, delay
|
||||
|
||||
|
||||
def gaussian_beam(
|
||||
xyz: list[NDArray],
|
||||
center: ArrayLike,
|
||||
w0: float,
|
||||
tilt: float,
|
||||
wl: float,
|
||||
) -> NDArray[numpy.complex128]:
|
||||
grids = numpy.asarray(numpy.meshgrid(*xyz, indexing='ij'))
|
||||
grids -= numpy.asarray(center)[:, None, None, None]
|
||||
|
||||
rot = numpy.array([
|
||||
[ numpy.cos(tilt), 0, numpy.sin(tilt)],
|
||||
[ 0, 1, 0],
|
||||
[-numpy.sin(tilt), 0, numpy.cos(tilt)],
|
||||
])
|
||||
|
||||
xx, yy, zz = numpy.einsum('ij,jxyz->ixyz', rot, grids)
|
||||
r2 = xx * xx + yy * yy
|
||||
z2 = zz * zz
|
||||
|
||||
zr = pi * w0 * w0 / wl
|
||||
zr2 = zr * zr
|
||||
wz2 = w0 * w0 * (1 + z2 / zr2)
|
||||
wz = numpy.sqrt(wz2) # == fwhm(z) / sqrt(2 * ln(2))
|
||||
|
||||
kk = 2 * pi / wl
|
||||
Rz = zz * (1 + zr2 / z2)
|
||||
gouy = numpy.arctan(zz / zr)
|
||||
|
||||
gaussian = w0 / wz * numpy.exp(-r2 / wz2) * numpy.exp(1j * (kk * zz + kk * r2 / 2 / Rz - gouy))
|
||||
|
||||
row = gaussian[:, :, gaussian.shape[2] // 2]
|
||||
norm = numpy.sqrt((row * row.conj()).sum())
|
||||
return gaussian / norm
|
||||
230
pcgen.py
Normal file
230
pcgen.py
Normal file
@ -0,0 +1,230 @@
|
||||
"""
|
||||
Routines for creating normalized 2D lattices and common photonic crystal
|
||||
cavity designs.
|
||||
"""
|
||||
|
||||
from typing import Sequence
|
||||
|
||||
import numpy
|
||||
from numpy.typing import NDArray
|
||||
|
||||
def triangular_lattice(
|
||||
dims: Sequence[int],
|
||||
asymmetrical: bool = False
|
||||
) -> NDArray[numpy.float64]:
|
||||
"""
|
||||
Return an ndarray of `[[x0, y0], [x1, y1], ...]` denoting lattice sites for
|
||||
a triangular lattice in 2D. The lattice will be centered around `(0, 0)`,
|
||||
unless `asymmetrical=True` in which case there will be extra holes in the +x
|
||||
direction.
|
||||
|
||||
Args:
|
||||
dims: Number of lattice sites in the [x, y] directions.
|
||||
asymmetrical: If `True`, each row in x will contain the same number of
|
||||
lattice sites. If `False`, the structure is symmetrical
|
||||
around `(0, 0)`.
|
||||
|
||||
Returns:
|
||||
`[[x0, y0], [x1, 1], ...]` denoting lattice sites.
|
||||
"""
|
||||
dims = numpy.asarray(dims, dtype=int)
|
||||
|
||||
if asymmetrical:
|
||||
k = 0
|
||||
else:
|
||||
k = 1
|
||||
|
||||
positions = []
|
||||
ymax = (dims[1] - 1)/2
|
||||
for j in numpy.linspace(-ymax, ymax, dims[0]):
|
||||
j_odd = numpy.floor(j).astype(int) % 2
|
||||
|
||||
x_offset = j_odd * 0.5
|
||||
y_offset = j * numpy.sqrt(3)/2
|
||||
|
||||
num_x = dims[0] - k * j_odd
|
||||
xmax = (dims[0] - 1)/2
|
||||
xs = numpy.linspace(-xmax, xmax - k * j_odd, num_x) + x_offset
|
||||
ys = numpy.full_like(xs, y_offset)
|
||||
|
||||
positions += [numpy.vstack((xs, ys)).T]
|
||||
|
||||
xy = numpy.vstack(tuple(positions))
|
||||
return xy[xy[:, 0].argsort(), ]
|
||||
|
||||
|
||||
def square_lattice(dims: Sequence[int]) -> NDArray[numpy.float64]:
|
||||
"""
|
||||
Return an ndarray of `[[x0, y0], [x1, y1], ...]` denoting lattice sites for
|
||||
a square lattice in 2D. The lattice will be centered around `(0, 0)`.
|
||||
|
||||
Args:
|
||||
dims: Number of lattice sites in the [x, y] directions.
|
||||
|
||||
Returns:
|
||||
`[[x0, y0], [x1, 1], ...]` denoting lattice sites.
|
||||
"""
|
||||
xs, ys = numpy.meshgrid(range(dims[0]), range(dims[1]), 'xy')
|
||||
xs -= dims[0]/2
|
||||
ys -= dims[1]/2
|
||||
xy = numpy.vstack((xs.flatten(), ys.flatten())).T
|
||||
return xy[xy[:, 0].argsort(), ]
|
||||
|
||||
# ### Photonic crystal functions ###
|
||||
|
||||
|
||||
def nanobeam_holes(
|
||||
a_defect: float,
|
||||
num_defect_holes: int,
|
||||
num_mirror_holes: int
|
||||
) -> NDArray[numpy.float64]:
|
||||
"""
|
||||
Returns a list of `[[x0, r0], [x1, r1], ...]` of nanobeam hole positions and radii.
|
||||
Creates a region in which the lattice constant and radius are progressively
|
||||
(linearly) altered over `num_defect_holes` holes until they reach the value
|
||||
specified by `a_defect`, then symmetrically returned to a lattice constant and
|
||||
radius of 1, which is repeated `num_mirror_holes` times on each side.
|
||||
|
||||
Args:
|
||||
a_defect: Minimum lattice constant for the defect, as a fraction of the
|
||||
mirror lattice constant (ie., for no defect, `a_defect = 1`).
|
||||
num_defect_holes: How many holes form the defect (per-side)
|
||||
num_mirror_holes: How many holes form the mirror (per-side)
|
||||
|
||||
Returns:
|
||||
ndarray `[[x0, r0], [x1, r1], ...]` of nanobeam hole positions and radii.
|
||||
"""
|
||||
a_values = numpy.linspace(a_defect, 1, num_defect_holes, endpoint=False)
|
||||
xs = a_values.cumsum() - (a_values[0] / 2) # Later mirroring makes center distance 2x as long
|
||||
mirror_xs = numpy.arange(1, num_mirror_holes + 1) + xs[-1]
|
||||
mirror_rs = numpy.ones_like(mirror_xs)
|
||||
return numpy.vstack((numpy.hstack((-mirror_xs[::-1], -xs[::-1], xs, mirror_xs)),
|
||||
numpy.hstack((mirror_rs[::-1], a_values[::-1], a_values, mirror_rs)))).T
|
||||
|
||||
|
||||
def ln_defect(
|
||||
mirror_dims: Sequence[int],
|
||||
defect_length: int,
|
||||
) -> NDArray[numpy.float64]:
|
||||
"""
|
||||
N-hole defect in a triangular lattice.
|
||||
|
||||
Args:
|
||||
mirror_dims: `[x, y]` mirror lengths (number of holes). Total number of holes
|
||||
is `2 * n + 1` in each direction.
|
||||
defect_length: Length of defect. Should be an odd number.
|
||||
|
||||
Returns:
|
||||
`[[x0, y0], [x1, y1], ...]` for all the holes
|
||||
"""
|
||||
if defect_length % 2 != 1:
|
||||
raise Exception('defect_length must be odd!')
|
||||
p = triangular_lattice([2 * d + 1 for d in mirror_dims])
|
||||
half_length = numpy.floor(defect_length / 2)
|
||||
hole_nums = numpy.arange(-half_length, half_length + 1)
|
||||
holes_to_keep = numpy.in1d(p[:, 0], hole_nums, invert=True)
|
||||
return p[numpy.logical_or(holes_to_keep, p[:, 1] != 0), ]
|
||||
|
||||
|
||||
def ln_shift_defect(
|
||||
mirror_dims: Sequence[int],
|
||||
defect_length: int,
|
||||
shifts_a: Sequence[float] = (0.15, 0, 0.075),
|
||||
shifts_r: Sequence[float] = (1, 1, 1)
|
||||
) -> NDArray[numpy.float64]:
|
||||
"""
|
||||
N-hole defect with shifted holes (intended to give the mode a gaussian profile
|
||||
in real- and k-space so as to improve both Q and confinement). Holes along the
|
||||
defect line are shifted and altered according to the `shifts_*` parameters.
|
||||
|
||||
Args:
|
||||
mirror_dims: [x, y] mirror lengths (number of holes). Total number of holes
|
||||
is `2 * n + 1` in each direction.
|
||||
defect_length: Length of defect. Should be an odd number.
|
||||
shifts_a: Percentage of a to shift (1st, 2nd, 3rd,...) holes along the defect line
|
||||
shifts_r: Factor to multiply the radius by. Should match length of `shifts_a`.
|
||||
|
||||
Returns:
|
||||
`[[x0, y0, r0], [x1, y1, r1], ...]` for all the holes
|
||||
"""
|
||||
xy = ln_defect(mirror_dims, defect_length)
|
||||
|
||||
# Add column for radius
|
||||
xyr = numpy.hstack((xy, numpy.ones((xy.shape[0], 1))))
|
||||
|
||||
# Shift holes
|
||||
assert len(shifts_a) == len(shifts_r)
|
||||
|
||||
x_removed = numpy.floor(defect_length / 2)
|
||||
|
||||
for ind in range(len(shifts_a)):
|
||||
for sign in (-1, 1):
|
||||
x_val = sign * (x_removed + ind + 1)
|
||||
which = numpy.logical_and(xyr[:, 0] == x_val, xyr[:, 1] == 0)
|
||||
xyr[which, ] = (x_val + numpy.sign(x_val) * shifts_a[ind], 0, shifts_r[ind])
|
||||
|
||||
return xyr
|
||||
|
||||
|
||||
def r6_defect(
|
||||
mirror_dims: Sequence[int],
|
||||
) -> NDArray[numpy.float64]:
|
||||
"""
|
||||
R6 defect in a triangular lattice.
|
||||
|
||||
Args:
|
||||
mirror_dims: [x, y] mirror lengths (number of holes). Total number of holes
|
||||
is `2 * n + 1` in each direction.
|
||||
|
||||
Returns:
|
||||
`[[x0, y0], [x1, y1], ...]` specifying hole centers.
|
||||
"""
|
||||
xy = triangular_lattice([2 * d + 1 for d in mirror_dims])
|
||||
|
||||
rem_holes_plus = numpy.array([[1, 0],
|
||||
[0.5, +numpy.sqrt(3)/2],
|
||||
[0.5, -numpy.sqrt(3)/2]])
|
||||
rem_holes = numpy.vstack((rem_holes_plus, -rem_holes_plus))
|
||||
|
||||
for rem_xy in rem_holes:
|
||||
xy = xy[(xy != rem_xy).any(axis=1), ]
|
||||
|
||||
return xy
|
||||
|
||||
|
||||
def l3_shift_perturbed_defect(
|
||||
mirror_dims: Sequence[int],
|
||||
perturbed_radius: float = 1.1,
|
||||
shifts_a: Sequence[float] = (),
|
||||
shifts_r: Sequence[float] = ()
|
||||
) -> NDArray[numpy.float64]:
|
||||
"""
|
||||
3-hole defect with perturbed hole sizes intended to form an upwards-directed
|
||||
beam. Can also include shifted holes along the defect line, intended
|
||||
to give the mode a more gaussian profile to improve Q.
|
||||
|
||||
Args:
|
||||
mirror_dims: [x, y] mirror lengths (number of holes). Total number of holes
|
||||
is `2 * n + 1` in each direction.
|
||||
perturbed_radius: Amount to perturb the radius of the holes used for beam-forming
|
||||
shifts_a: Percentage of a to shift (1st, 2nd, 3rd,...) holes along the defect line
|
||||
shifts_r: Factor to multiply the radius by. Should match length of `shifts_a`
|
||||
|
||||
Returns:
|
||||
`[[x0, y0, r0], [x1, y1, r1], ...]` for all the holes
|
||||
"""
|
||||
xyr = ln_shift_defect(mirror_dims, 3, shifts_a, shifts_r)
|
||||
|
||||
abs_x, abs_y = (numpy.fabs(xyr[:, i]) for i in (0, 1))
|
||||
|
||||
# Sorted unique xs and ys
|
||||
# Ignore row y=0 because it might have shifted holes
|
||||
xs = numpy.unique(abs_x[abs_x != 0])
|
||||
ys = numpy.unique(abs_y)
|
||||
|
||||
# which holes should be perturbed? (xs[[3, 7]], ys[1]) and (xs[[2, 6]], ys[2])
|
||||
perturbed_holes = numpy.array([(xs[a], ys[b]) for a, b in ((3, 1), (7, 1), (2, 2), (6, 2))])
|
||||
for row in xyr:
|
||||
if (numpy.fabs(row[:2])[None, :] == perturbed_holes).all(axis=1).any():
|
||||
row[2] = perturbed_radius
|
||||
return xyr
|
||||
1664
pdoc__init__.py
Normal file
1664
pdoc__init__.py
Normal file
File diff suppressed because it is too large
Load Diff
569
pylintrc
Normal file
569
pylintrc
Normal file
@ -0,0 +1,569 @@
|
||||
[MASTER]
|
||||
|
||||
# A comma-separated list of package or module names from where C extensions may
|
||||
# be loaded. Extensions are loading into the active Python interpreter and may
|
||||
# run arbitrary code.
|
||||
extension-pkg-whitelist=
|
||||
|
||||
# Add files or directories to the blacklist. They should be base names, not
|
||||
# paths.
|
||||
ignore=CVS,.git
|
||||
|
||||
# Add files or directories matching the regex patterns to the blacklist. The
|
||||
# regex matches against base names, not paths.
|
||||
ignore-patterns=
|
||||
|
||||
# Python code to execute, usually for sys.path manipulation such as
|
||||
# pygtk.require().
|
||||
#init-hook=
|
||||
|
||||
# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
|
||||
# number of processors available to use.
|
||||
jobs=1
|
||||
|
||||
# Control the amount of potential inferred values when inferring a single
|
||||
# object. This can help the performance when dealing with large functions or
|
||||
# complex, nested conditions.
|
||||
limit-inference-results=100
|
||||
|
||||
# List of plugins (as comma separated values of python modules names) to load,
|
||||
# usually to register additional checkers.
|
||||
load-plugins=
|
||||
|
||||
# Pickle collected data for later comparisons.
|
||||
persistent=yes
|
||||
|
||||
# Specify a configuration file.
|
||||
#rcfile=
|
||||
|
||||
# When enabled, pylint would attempt to guess common misconfiguration and emit
|
||||
# user-friendly hints instead of false-positive error messages.
|
||||
suggestion-mode=yes
|
||||
|
||||
# Allow loading of arbitrary C extensions. Extensions are imported into the
|
||||
# active Python interpreter and may run arbitrary code.
|
||||
unsafe-load-any-extension=no
|
||||
|
||||
|
||||
[MESSAGES CONTROL]
|
||||
|
||||
# Only show warnings with the listed confidence levels. Leave empty to show
|
||||
# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED.
|
||||
confidence=
|
||||
|
||||
# Disable the message, report, category or checker with the given id(s). You
|
||||
# can either give multiple identifiers separated by comma (,) or put this
|
||||
# option multiple times (only on the command line, not in the configuration
|
||||
# file where it should appear only once). You can also use "--disable=all" to
|
||||
# disable everything first and then reenable specific checks. For example, if
|
||||
# you want to run only the similarities checker, you can use "--disable=all
|
||||
# --enable=similarities". If you want to run only the classes checker, but have
|
||||
# no Warning level messages displayed, use "--disable=all --enable=classes
|
||||
# --disable=W".
|
||||
disable=print-statement,
|
||||
parameter-unpacking,
|
||||
unpacking-in-except,
|
||||
old-raise-syntax,
|
||||
backtick,
|
||||
long-suffix,
|
||||
old-ne-operator,
|
||||
old-octal-literal,
|
||||
import-star-module-level,
|
||||
non-ascii-bytes-literal,
|
||||
raw-checker-failed,
|
||||
bad-inline-option,
|
||||
locally-disabled,
|
||||
file-ignored,
|
||||
suppressed-message,
|
||||
useless-suppression,
|
||||
deprecated-pragma,
|
||||
use-symbolic-message-instead,
|
||||
apply-builtin,
|
||||
basestring-builtin,
|
||||
buffer-builtin,
|
||||
cmp-builtin,
|
||||
coerce-builtin,
|
||||
execfile-builtin,
|
||||
file-builtin,
|
||||
long-builtin,
|
||||
raw_input-builtin,
|
||||
reduce-builtin,
|
||||
standarderror-builtin,
|
||||
unicode-builtin,
|
||||
xrange-builtin,
|
||||
coerce-method,
|
||||
delslice-method,
|
||||
getslice-method,
|
||||
setslice-method,
|
||||
no-absolute-import,
|
||||
old-division,
|
||||
dict-iter-method,
|
||||
dict-view-method,
|
||||
next-method-called,
|
||||
metaclass-assignment,
|
||||
indexing-exception,
|
||||
raising-string,
|
||||
reload-builtin,
|
||||
oct-method,
|
||||
hex-method,
|
||||
nonzero-method,
|
||||
cmp-method,
|
||||
input-builtin,
|
||||
round-builtin,
|
||||
intern-builtin,
|
||||
unichr-builtin,
|
||||
map-builtin-not-iterating,
|
||||
zip-builtin-not-iterating,
|
||||
range-builtin-not-iterating,
|
||||
filter-builtin-not-iterating,
|
||||
using-cmp-argument,
|
||||
eq-without-hash,
|
||||
div-method,
|
||||
idiv-method,
|
||||
rdiv-method,
|
||||
exception-message-attribute,
|
||||
invalid-str-codec,
|
||||
sys-max-int,
|
||||
bad-python3-import,
|
||||
deprecated-string-function,
|
||||
deprecated-str-translate-call,
|
||||
deprecated-itertools-function,
|
||||
deprecated-types-field,
|
||||
next-method-defined,
|
||||
dict-items-not-iterating,
|
||||
dict-keys-not-iterating,
|
||||
dict-values-not-iterating,
|
||||
deprecated-operator-function,
|
||||
deprecated-urllib-function,
|
||||
xreadlines-attribute,
|
||||
deprecated-sys-function,
|
||||
exception-escape,
|
||||
comprehension-escape,
|
||||
invalid-name,
|
||||
missing-function-docstring,
|
||||
trailing-newlines,
|
||||
too-many-locals,
|
||||
too-many-arguments,
|
||||
too-many-statements,
|
||||
too-many-instance-attributes,
|
||||
no-else-return,
|
||||
pointless-string-statement,
|
||||
|
||||
# Enable the message, report, category or checker with the given id(s). You can
|
||||
# either give multiple identifier separated by comma (,) or put this option
|
||||
# multiple time (only on the command line, not in the configuration file where
|
||||
# it should appear only once). See also the "--disable" option for examples.
|
||||
enable=c-extension-no-member
|
||||
|
||||
|
||||
[REPORTS]
|
||||
|
||||
# Python expression which should return a note less than 10 (10 is the highest
|
||||
# note). You have access to the variables errors warning, statement which
|
||||
# respectively contain the number of errors / warnings messages and the total
|
||||
# number of statements analyzed. This is used by the global evaluation report
|
||||
# (RP0004).
|
||||
evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
|
||||
|
||||
# Template used to display messages. This is a python new-style format string
|
||||
# used to format the message information. See doc for all details.
|
||||
#msg-template=
|
||||
|
||||
# Set the output format. Available formats are text, parseable, colorized, json
|
||||
# and msvs (visual studio). You can also give a reporter class, e.g.
|
||||
# mypackage.mymodule.MyReporterClass.
|
||||
output-format=text
|
||||
|
||||
# Tells whether to display a full report or only the messages.
|
||||
reports=no
|
||||
|
||||
# Activate the evaluation score.
|
||||
score=yes
|
||||
|
||||
|
||||
[REFACTORING]
|
||||
|
||||
# Maximum number of nested blocks for function / method body
|
||||
max-nested-blocks=5
|
||||
|
||||
# Complete name of functions that never returns. When checking for
|
||||
# inconsistent-return-statements if a never returning function is called then
|
||||
# it will be considered as an explicit return statement and no message will be
|
||||
# printed.
|
||||
never-returning-functions=sys.exit
|
||||
|
||||
|
||||
[BASIC]
|
||||
|
||||
# Naming style matching correct argument names.
|
||||
argument-naming-style=snake_case
|
||||
|
||||
# Regular expression matching correct argument names. Overrides argument-
|
||||
# naming-style.
|
||||
#argument-rgx=
|
||||
|
||||
# Naming style matching correct attribute names.
|
||||
attr-naming-style=snake_case
|
||||
|
||||
# Regular expression matching correct attribute names. Overrides attr-naming-
|
||||
# style.
|
||||
#attr-rgx=
|
||||
|
||||
# Bad variable names which should always be refused, separated by a comma.
|
||||
bad-names=foo,
|
||||
bar,
|
||||
baz,
|
||||
toto,
|
||||
tutu,
|
||||
tata,
|
||||
nom
|
||||
|
||||
# Naming style matching correct class attribute names.
|
||||
class-attribute-naming-style=any
|
||||
|
||||
# Regular expression matching correct class attribute names. Overrides class-
|
||||
# attribute-naming-style.
|
||||
#class-attribute-rgx=
|
||||
|
||||
# Naming style matching correct class names.
|
||||
class-naming-style=PascalCase
|
||||
|
||||
# Regular expression matching correct class names. Overrides class-naming-
|
||||
# style.
|
||||
#class-rgx=
|
||||
|
||||
# Naming style matching correct constant names.
|
||||
const-naming-style=UPPER_CASE
|
||||
|
||||
# Regular expression matching correct constant names. Overrides const-naming-
|
||||
# style.
|
||||
#const-rgx=
|
||||
|
||||
# Minimum line length for functions/classes that require docstrings, shorter
|
||||
# ones are exempt.
|
||||
docstring-min-length=-1
|
||||
|
||||
# Naming style matching correct function names.
|
||||
function-naming-style=snake_case
|
||||
|
||||
# Regular expression matching correct function names. Overrides function-
|
||||
# naming-style.
|
||||
#function-rgx=
|
||||
|
||||
# Good variable names which should always be accepted, separated by a comma.
|
||||
good-names=e, h, s, j, x, y, a, b
|
||||
ex,
|
||||
Run,
|
||||
_
|
||||
|
||||
# Include a hint for the correct naming format with invalid-name.
|
||||
include-naming-hint=no
|
||||
|
||||
# Naming style matching correct inline iteration names.
|
||||
inlinevar-naming-style=any
|
||||
|
||||
# Regular expression matching correct inline iteration names. Overrides
|
||||
# inlinevar-naming-style.
|
||||
#inlinevar-rgx=
|
||||
|
||||
# Naming style matching correct method names.
|
||||
method-naming-style=snake_case
|
||||
|
||||
# Regular expression matching correct method names. Overrides method-naming-
|
||||
# style.
|
||||
#method-rgx=
|
||||
|
||||
# Naming style matching correct module names.
|
||||
module-naming-style=snake_case
|
||||
|
||||
# Regular expression matching correct module names. Overrides module-naming-
|
||||
# style.
|
||||
#module-rgx=
|
||||
|
||||
# Colon-delimited sets of names that determine each other's naming style when
|
||||
# the name regexes allow several styles.
|
||||
name-group=
|
||||
|
||||
# Regular expression which should only match function or class names that do
|
||||
# not require a docstring.
|
||||
no-docstring-rgx=^_
|
||||
|
||||
# List of decorators that produce properties, such as abc.abstractproperty. Add
|
||||
# to this list to register other decorators that produce valid properties.
|
||||
# These decorators are taken in consideration only for invalid-name.
|
||||
property-classes=abc.abstractproperty
|
||||
|
||||
# Naming style matching correct variable names.
|
||||
variable-naming-style=any
|
||||
|
||||
# Regular expression matching correct variable names. Overrides variable-
|
||||
# naming-style.
|
||||
#variable-rgx=
|
||||
|
||||
|
||||
[FORMAT]
|
||||
|
||||
# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
|
||||
expected-line-ending-format=
|
||||
|
||||
# Regexp for a line that is allowed to be longer than the limit.
|
||||
ignore-long-lines=^\s*(# )?<?https?://\S+>?$
|
||||
|
||||
# Number of spaces of indent required inside a hanging or continued line.
|
||||
indent-after-paren=4
|
||||
|
||||
# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
|
||||
# tab).
|
||||
indent-string=' '
|
||||
|
||||
# Maximum number of characters on a single line.
|
||||
max-line-length=160
|
||||
|
||||
# Maximum number of lines in a module.
|
||||
max-module-lines=1000
|
||||
|
||||
# List of optional constructs for which whitespace checking is disabled. `dict-
|
||||
# separator` is used to allow tabulation in dicts, etc.: {1 : 1,\n222: 2}.
|
||||
# `trailing-comma` allows a space between comma and closing bracket: (a, ).
|
||||
# `empty-line` allows space-only lines.
|
||||
no-space-check=trailing-comma,
|
||||
dict-separator
|
||||
|
||||
# Allow the body of a class to be on the same line as the declaration if body
|
||||
# contains single statement.
|
||||
single-line-class-stmt=no
|
||||
|
||||
# Allow the body of an if to be on the same line as the test if there is no
|
||||
# else.
|
||||
single-line-if-stmt=no
|
||||
|
||||
|
||||
[LOGGING]
|
||||
|
||||
# Format style used to check logging format string. `old` means using %
|
||||
# formatting, while `new` is for `{}` formatting.
|
||||
logging-format-style=old
|
||||
|
||||
# Logging modules to check that the string format arguments are in logging
|
||||
# function parameter format.
|
||||
logging-modules=logging
|
||||
|
||||
|
||||
[MISCELLANEOUS]
|
||||
|
||||
# List of note tags to take in consideration, separated by a comma.
|
||||
notes=FIXME,
|
||||
XXX,
|
||||
TODO
|
||||
|
||||
|
||||
[SIMILARITIES]
|
||||
|
||||
# Ignore comments when computing similarities.
|
||||
ignore-comments=yes
|
||||
|
||||
# Ignore docstrings when computing similarities.
|
||||
ignore-docstrings=yes
|
||||
|
||||
# Ignore imports when computing similarities.
|
||||
ignore-imports=yes
|
||||
|
||||
# Minimum lines number of a similarity.
|
||||
min-similarity-lines=4
|
||||
|
||||
|
||||
[SPELLING]
|
||||
|
||||
# Limits count of emitted suggestions for spelling mistakes.
|
||||
max-spelling-suggestions=4
|
||||
|
||||
# Spelling dictionary name. Available dictionaries: none. To make it working
|
||||
# install python-enchant package..
|
||||
spelling-dict=
|
||||
|
||||
# List of comma separated words that should not be checked.
|
||||
spelling-ignore-words=
|
||||
|
||||
# A path to a file that contains private dictionary; one word per line.
|
||||
spelling-private-dict-file=
|
||||
|
||||
# Tells whether to store unknown words to indicated private dictionary in
|
||||
# --spelling-private-dict-file option instead of raising a message.
|
||||
spelling-store-unknown-words=no
|
||||
|
||||
|
||||
[TYPECHECK]
|
||||
|
||||
# List of decorators that produce context managers, such as
|
||||
# contextlib.contextmanager. Add to this list to register other decorators that
|
||||
# produce valid context managers.
|
||||
contextmanager-decorators=contextlib.contextmanager
|
||||
|
||||
# List of members which are set dynamically and missed by pylint inference
|
||||
# system, and so shouldn't trigger E1101 when accessed. Python regular
|
||||
# expressions are accepted.
|
||||
generated-members=
|
||||
|
||||
# Tells whether missing members accessed in mixin class should be ignored. A
|
||||
# mixin class is detected if its name ends with "mixin" (case insensitive).
|
||||
ignore-mixin-members=yes
|
||||
|
||||
# Tells whether to warn about missing members when the owner of the attribute
|
||||
# is inferred to be None.
|
||||
ignore-none=yes
|
||||
|
||||
# This flag controls whether pylint should warn about no-member and similar
|
||||
# checks whenever an opaque object is returned when inferring. The inference
|
||||
# can return multiple potential results while evaluating a Python object, but
|
||||
# some branches might not be evaluated, which results in partial inference. In
|
||||
# that case, it might be useful to still emit no-member and other checks for
|
||||
# the rest of the inferred objects.
|
||||
ignore-on-opaque-inference=yes
|
||||
|
||||
# List of class names for which member attributes should not be checked (useful
|
||||
# for classes with dynamically set attributes). This supports the use of
|
||||
# qualified names.
|
||||
ignored-classes=optparse.Values,thread._local,_thread._local
|
||||
|
||||
# List of module names for which member attributes should not be checked
|
||||
# (useful for modules/projects where namespaces are manipulated during runtime
|
||||
# and thus existing member attributes cannot be deduced by static analysis. It
|
||||
# supports qualified module names, as well as Unix pattern matching.
|
||||
ignored-modules=
|
||||
|
||||
# Show a hint with possible names when a member name was not found. The aspect
|
||||
# of finding the hint is based on edit distance.
|
||||
missing-member-hint=yes
|
||||
|
||||
# The minimum edit distance a name should have in order to be considered a
|
||||
# similar match for a missing member name.
|
||||
missing-member-hint-distance=1
|
||||
|
||||
# The total number of similar names that should be taken in consideration when
|
||||
# showing a hint for a missing member.
|
||||
missing-member-max-choices=1
|
||||
|
||||
|
||||
[VARIABLES]
|
||||
|
||||
# List of additional names supposed to be defined in builtins. Remember that
|
||||
# you should avoid defining new builtins when possible.
|
||||
additional-builtins=
|
||||
|
||||
# Tells whether unused global variables should be treated as a violation.
|
||||
allow-global-unused-variables=yes
|
||||
|
||||
# List of strings which can identify a callback function by name. A callback
|
||||
# name must start or end with one of those strings.
|
||||
callbacks=cb_,
|
||||
_cb
|
||||
|
||||
# A regular expression matching the name of dummy variables (i.e. expected to
|
||||
# not be used).
|
||||
dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
|
||||
|
||||
# Argument names that match this expression will be ignored. Default to name
|
||||
# with leading underscore.
|
||||
ignored-argument-names=_.*|^ignored_|^unused_
|
||||
|
||||
# Tells whether we should check for unused import in __init__ files.
|
||||
init-import=no
|
||||
|
||||
# List of qualified module names which can have objects that can redefine
|
||||
# builtins.
|
||||
redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io
|
||||
|
||||
|
||||
[CLASSES]
|
||||
|
||||
# List of method names used to declare (i.e. assign) instance attributes.
|
||||
defining-attr-methods=__init__,
|
||||
__new__,
|
||||
setUp
|
||||
|
||||
# List of member names, which should be excluded from the protected access
|
||||
# warning.
|
||||
exclude-protected=_asdict,
|
||||
_fields,
|
||||
_replace,
|
||||
_source,
|
||||
_make
|
||||
|
||||
# List of valid names for the first argument in a class method.
|
||||
valid-classmethod-first-arg=cls
|
||||
|
||||
# List of valid names for the first argument in a metaclass class method.
|
||||
valid-metaclass-classmethod-first-arg=cls
|
||||
|
||||
|
||||
[DESIGN]
|
||||
|
||||
# Maximum number of arguments for function / method.
|
||||
max-args=5
|
||||
|
||||
# Maximum number of attributes for a class (see R0902).
|
||||
max-attributes=7
|
||||
|
||||
# Maximum number of boolean expressions in an if statement.
|
||||
max-bool-expr=5
|
||||
|
||||
# Maximum number of branch for function / method body.
|
||||
max-branches=12
|
||||
|
||||
# Maximum number of locals for function / method body.
|
||||
max-locals=15
|
||||
|
||||
# Maximum number of parents for a class (see R0901).
|
||||
max-parents=7
|
||||
|
||||
# Maximum number of public methods for a class (see R0904).
|
||||
max-public-methods=20
|
||||
|
||||
# Maximum number of return / yield for function / method body.
|
||||
max-returns=6
|
||||
|
||||
# Maximum number of statements in function / method body.
|
||||
max-statements=50
|
||||
|
||||
# Minimum number of public methods for a class (see R0903).
|
||||
min-public-methods=2
|
||||
|
||||
|
||||
[IMPORTS]
|
||||
|
||||
# Allow wildcard imports from modules that define __all__.
|
||||
allow-wildcard-with-all=no
|
||||
|
||||
# Analyse import fallback blocks. This can be used to support both Python 2 and
|
||||
# 3 compatible code, which means that the block might have code that exists
|
||||
# only in one or another interpreter, leading to false positives when analysed.
|
||||
analyse-fallback-blocks=no
|
||||
|
||||
# Deprecated modules which should not be used, separated by a comma.
|
||||
deprecated-modules=optparse,tkinter.tix
|
||||
|
||||
# Create a graph of external dependencies in the given file (report RP0402 must
|
||||
# not be disabled).
|
||||
ext-import-graph=
|
||||
|
||||
# Create a graph of every (i.e. internal and external) dependencies in the
|
||||
# given file (report RP0402 must not be disabled).
|
||||
import-graph=
|
||||
|
||||
# Create a graph of internal dependencies in the given file (report RP0402 must
|
||||
# not be disabled).
|
||||
int-import-graph=
|
||||
|
||||
# Force import order to recognize a module as part of the standard
|
||||
# compatibility libraries.
|
||||
known-standard-library=
|
||||
|
||||
# Force import order to recognize a module as part of a third party library.
|
||||
known-third-party=enchant
|
||||
|
||||
|
||||
[EXCEPTIONS]
|
||||
|
||||
# Exceptions that will emit a warning when being caught. Defaults to
|
||||
# "Exception".
|
||||
overgeneral-exceptions=Exception
|
||||
@ -39,7 +39,7 @@ include = [
|
||||
]
|
||||
dynamic = ["version"]
|
||||
dependencies = [
|
||||
"numpy>=1.26",
|
||||
"numpy>=2.0",
|
||||
"scipy~=1.14",
|
||||
]
|
||||
|
||||
|
||||
BIN
simulation_output.h5
Normal file
BIN
simulation_output.h5
Normal file
Binary file not shown.
429
test.py
Normal file
429
test.py
Normal file
@ -0,0 +1,429 @@
|
||||
from typing import Tuple
|
||||
import multiprocessing
|
||||
import logging
|
||||
import copy
|
||||
from itertools import chain
|
||||
|
||||
import pyopencl, meanas, gridlock
|
||||
import numpy
|
||||
from numpy import pi, sin, cos, exp
|
||||
from numpy.linalg import norm
|
||||
|
||||
from meanas import fdtd, fdfd
|
||||
from meanas.fdmath import vec
|
||||
from meanas.fdfd.waveguide_3d import compute_source, compute_overlap_e
|
||||
from meanas.fdfd import operators
|
||||
from meanas.fdtd import maxwell_e, maxwell_h, cpml_params, updates_with_cpml, poynting
|
||||
|
||||
|
||||
numpy.set_printoptions(linewidth=int(1e10))
|
||||
|
||||
logging.basicConfig(level=logging.DEBUG)
|
||||
logger = logging.getLogger(__name__)
|
||||
logging.getLogger('matplotlib').setLevel(logging.WARNING)
|
||||
logging.getLogger('pyopencl').setLevel(logging.WARNING)
|
||||
logging.getLogger('pytools').setLevel(logging.WARNING)
|
||||
|
||||
|
||||
fh = logging.FileHandler('opt.log')
|
||||
fh.setLevel(logging.INFO)
|
||||
logger.addHandler(fh)
|
||||
|
||||
|
||||
def saveplot_2d_mp(*args):
|
||||
multiprocessing.Process(target=saveplot_2d, args=args).start()
|
||||
|
||||
|
||||
def saveplot_2d(val, name, xz_coords):
|
||||
val = numpy.squeeze(val)
|
||||
pyplot.figure(figsize=(8, 6))
|
||||
xz_grids = numpy.meshgrid(*xz_coords, indexing='ij')
|
||||
vmax = numpy.abs(val).max()
|
||||
if (val < 0).any():
|
||||
args = {'vmin': -vmax, 'vmax': vmax, 'cmap': 'seismic'}
|
||||
else:
|
||||
args = {'vmin': 0, 'vmax': vmax, 'cmap': 'hot'}
|
||||
|
||||
pyplot.pcolormesh(*xz_grids, val, **args)
|
||||
pyplot.colorbar(orientation='horizontal')
|
||||
pyplot.title(f'{name}')
|
||||
pyplot.gca().set_aspect('equal', adjustable='box')
|
||||
pyplot.savefig(f'{name}.png', dpi=240)
|
||||
pyplot.close()
|
||||
|
||||
|
||||
def pulse(wl, dwl, dt, turn_on=1e-10):
|
||||
# dt * dw = 4 * ln(2)
|
||||
w = 2 * pi / wl
|
||||
freq = 1 / wl
|
||||
fwhm = dwl * w * w / (2 * pi)
|
||||
alpha = (fwhm * fwhm) / 8 * numpy.log(2)
|
||||
delay = numpy.sqrt(-numpy.log(turn_on) / alpha)
|
||||
delay = numpy.ceil(delay * freq) / freq # force delay to integer number of periods to maintain phase
|
||||
logger.info(f'src_time {2 * delay / dt}')
|
||||
|
||||
n = numpy.floor(pi / (w * dt))
|
||||
logger.info(f'save timestep would be {n} * dt = {n * dt}')
|
||||
|
||||
# nrm = numpy.exp(-w * w / alpha) / 2
|
||||
|
||||
def source_phasor(i):
|
||||
t0 = i * dt - delay
|
||||
envelope = numpy.sqrt(numpy.sqrt(2 * alpha / pi)) * numpy.exp(-alpha * t0**2)
|
||||
# if t0 < 0:
|
||||
# envelope = numpy.exp(-alpha * t0**2)
|
||||
# else:
|
||||
# envelope = 1
|
||||
return envelope, numpy.cos(w * t0), numpy.sin(w * t0)
|
||||
return source_phasor, delay, n #, nrm
|
||||
|
||||
|
||||
def get_wgmode_xp(half_dims, polarity, grid, epsilon, wl, dxes):
|
||||
dims = [-half_dims, half_dims]
|
||||
dims[0][0] = dims[1][0]
|
||||
ind_dims = (grid.pos2ind(dims[0], which_shifts=None).astype(int),
|
||||
grid.pos2ind(dims[1], which_shifts=None).astype(int))
|
||||
wg_slices = tuple(slice(i, f+1) for i, f in zip(*ind_dims))
|
||||
wg_args = {
|
||||
'omega': 2 * pi / wl,
|
||||
'slices': wg_slices,
|
||||
'dxes': dxes,
|
||||
'axis': 0,
|
||||
'polarity': polarity,
|
||||
}
|
||||
|
||||
wg_results = fdfd.waveguide_3d.solve_mode(mode_number=0, **wg_args, epsilon=epsilon)
|
||||
return wg_args, wg_results
|
||||
|
||||
|
||||
def get_gaussian(m, grid, dxes, wl):
|
||||
def grid2gaussian(xyz, center, w0=4600, tilt=numpy.deg2rad(-8)):
|
||||
xs, ys, zs = xyz
|
||||
xs -= center[0]
|
||||
ys -= center[1]
|
||||
zs -= center[2]
|
||||
xg, yg, zg = numpy.meshgrid(xs, ys, zs, indexing='ij')
|
||||
|
||||
rot = numpy.array([[ cos(tilt), 0, sin(tilt)],
|
||||
[ 0, 1, 0],
|
||||
[-sin(tilt), 0, cos(tilt)]])
|
||||
|
||||
x, y, z = (rot @ numpy.stack((xg.ravel(), yg.ravel(), zg.ravel()))).reshape(3, *grid.shape)
|
||||
r2 = x * x + y * y # sq. distance from beam center along tilted plane
|
||||
z2 = z * z # sq. distance from waist along centerline
|
||||
|
||||
zr = pi * w0 * w0 / wl
|
||||
zr2 = zr * zr
|
||||
wz2 = w0 * w0 * (1 + z2 / zr2)
|
||||
wz = numpy.sqrt(wz2)
|
||||
|
||||
k = 2 * pi / wl
|
||||
Rz = z * (1 + zr2 / z2)
|
||||
gouy = numpy.arctan(z / zr)
|
||||
|
||||
gaussian = w0 / wz * exp(-r2 / wz2) * exp(1j * (k * z + k * r2 / 2 / Rz - gouy))
|
||||
# window_x = scipy.signal.windows.kaiser(xs.size, 14)
|
||||
# gaussian *= window_x[:, None, None]
|
||||
return gaussian
|
||||
|
||||
zsEy = grid.shifted_xyz(1)[2]
|
||||
gaussianEy = grid2gaussian(grid.shifted_xyz(1), [0, 0, zsEy[m[2]]])
|
||||
|
||||
normEy = gaussianEy[m[0]:-m[0], :, m[2]]
|
||||
gaussianEy /= numpy.sqrt((normEy[1].conj() * normEy[1]).sum())
|
||||
|
||||
return gaussianEy
|
||||
|
||||
|
||||
def run(pml=(10, 0, 10), dx=20, wl=1310, dwl=130, wg_zh=400, wg_x=-7500, fiber_z=1000, max_t=int(10e3)):
|
||||
omega = 2 * pi / wl
|
||||
|
||||
x_min = -10e3 - pml[0] * dx
|
||||
x_max = 10e3 + pml[0] * dx
|
||||
z_min = -600 - pml[2] * dx
|
||||
z_max = 1400 + pml[2] * dx
|
||||
|
||||
ex = numpy.arange(x_min, x_max + dx / 2, dx)
|
||||
ez = numpy.arange(z_min, z_max + dx / 2, dx)
|
||||
exyz = [ex, [-dx / 2, dx / 2], ez]
|
||||
grid = gridlock.Grid(exyz, periodic=True)
|
||||
epsilon = grid.allocate(1.45**2)
|
||||
|
||||
def unvec(f):
|
||||
return meanas.fdmath.unvec(f, grid.shape)
|
||||
|
||||
# grid.draw_slab(epsilon, surface_normal=2, center=[0, 0, 0], thickness=160, eps=3.5**2)
|
||||
|
||||
|
||||
e = numpy.zeros_like(epsilon, dtype=numpy.float32)
|
||||
h = numpy.zeros_like(epsilon, dtype=numpy.float32)
|
||||
|
||||
dxes = [grid.dxyz, grid.autoshifted_dxyz()]
|
||||
min_dx = min(min(dxn) for dxn in chain(*dxes))
|
||||
dt = min_dx * .99 / numpy.sqrt(3)
|
||||
|
||||
source_phasor, delay, n_fft = pulse(wl, dwl, dt)
|
||||
if 2 * delay / dt > max_t:
|
||||
raise Exception('Source extends beyond end of simulation')
|
||||
|
||||
|
||||
m = numpy.array(pml) + 10
|
||||
m[2] = grid.pos2ind([0, 0, fiber_z], which_shifts=0)[2] - grid.shape[2]
|
||||
|
||||
ey_gauss = numpy.zeros_like(epsilon, dtype=complex)
|
||||
ey_gauss = get_gaussian(m, grid, dxes, wl / 1.45)
|
||||
e_gauss = numpy.zeros_like(epsilon, dtype=numpy.complex64)
|
||||
e_gauss[1] = ey_gauss
|
||||
mask = numpy.zeros_like(epsilon, dtype=int)
|
||||
mask[..., :m[2]] = 1
|
||||
src_op = operators.e_boundary_source(mask=vec(mask), omega=omega, dxes=dxes, epsilon=vec(epsilon))
|
||||
|
||||
def zero_pmls(c):
|
||||
for a in range(3):
|
||||
c[a][:pml[0]+1, :, :] = 0
|
||||
c[a][-pml[0]-1:, :, :] = 0
|
||||
c[a][:, :, :pml[2]+1] = 0
|
||||
c[a][:, :, -pml[2]-1:] = 0
|
||||
return c
|
||||
|
||||
# J = unvec(src_op @ vec(e_gauss))
|
||||
# J[:, :12, :, :] = 0
|
||||
# J[:, -12:, :, :] = 0
|
||||
# J[:, :, :, :12] = 0
|
||||
# J[:, :, :, -12:] = 0
|
||||
# zero_pmls(J)
|
||||
|
||||
J = numpy.zeros_like(epsilon, dtype=complex)
|
||||
J[1, 500, 0, 60] = 1
|
||||
zero_pmls(J)
|
||||
|
||||
half_dims = numpy.array([wg_x, dx, wg_zh])
|
||||
wg_args, wg_results = get_wgmode_xp(half_dims, -1, grid, wl, dxes)
|
||||
|
||||
E_out = compute_overlap_e(E=wg_results['E'], wavenumber=wg_results['wavenumber'],
|
||||
dxes=dxes, axis=0, polarity=+1, slices=wg_args['slices'])
|
||||
|
||||
|
||||
jr = (J.real / epsilon).astype(numpy.float32)
|
||||
ji = (J.imag / epsilon).astype(numpy.float32)
|
||||
|
||||
|
||||
eph = numpy.zeros_like(e, dtype=numpy.complex64)
|
||||
ephm = numpy.zeros_like(e, dtype=numpy.complex64)
|
||||
# powers = numpy.zeros((max_t, 5))
|
||||
p_ph = 0
|
||||
|
||||
pml_params = [[cpml_params(axis=dd, polarity=pp, dt=dt,
|
||||
thickness=pml[dd], epsilon_eff=1.0**2)
|
||||
if pml[dd] > 0 else None
|
||||
for pp in (-1, +1)]
|
||||
for dd in range(3)]
|
||||
update_E, update_H = updates_with_cpml(cpml_params=pml_params, dt=dt,
|
||||
dxes=dxes, epsilon=epsilon)
|
||||
|
||||
mov_interval = 10
|
||||
mov = numpy.empty((max_t // mov_interval, e.shape[1], e.shape[3]), dtype=numpy.float32)
|
||||
|
||||
for t in range(max_t):
|
||||
update_E(e, h, epsilon)
|
||||
_, cm5, sm5 = source_phasor(t - 0.5)
|
||||
ephm += (cm5 - 1j * sm5) * e
|
||||
|
||||
a, c, s = source_phasor(t)
|
||||
p_ph += a * c * c
|
||||
e -= (a * c) * jr - (a * s) * ji
|
||||
|
||||
update_H(e, h)
|
||||
|
||||
_, cp5, sp5 = source_phasor(t + 0.5)
|
||||
eph += (cp5 - 1j * sp5) * e
|
||||
|
||||
# S = poynting(e, h, epsilon)
|
||||
#
|
||||
# powers[t, :] = (
|
||||
# numpy.sum(S[2, m[0]+3:-m[0]-2, :, m[2]-6]), # below src
|
||||
# numpy.sum(S[2, m[0]+3:-m[0]-2, :, m[2]+4]), # above src
|
||||
# numpy.sum(S[2, m[0]+3:-m[0]-2, :, pml[2]+2]), # bottom
|
||||
# numpy.sum(S[0, +m[0]+2, :, pml[2]+3:m[2]+4]), # left
|
||||
# numpy.sum(S[0, -m[0]-2, :, pml[2]+3:m[2]+4]), # right
|
||||
# )
|
||||
|
||||
if t % mov_interval == 0:
|
||||
mov[t // mov_interval] = e[1, :, 0, :].real
|
||||
|
||||
eph *= dt / p_ph
|
||||
ephm *= dt / p_ph
|
||||
|
||||
src_power = -(J * eph).real.sum() / 2 * dx ** 3
|
||||
|
||||
hph = meanas.fdfd.functional.e2h(omega=omega, dxes=dxes)(eph)
|
||||
sph = meanas.fdtd.poynting(e=eph, h=hph.conj(), dxes=dxes)
|
||||
planes_powers = numpy.array((
|
||||
-sph[0, 11, :, 11:-12].sum(),
|
||||
+sph[0, -12, :, 11:-12].sum(),
|
||||
-sph[2, 11:-12, :, 11].sum(),
|
||||
+sph[2, 11:-12, :, -12].sum(),
|
||||
)).real / 2
|
||||
planes_power = planes_powers.sum()
|
||||
|
||||
print(f'{src_power=}, {planes_power=}')
|
||||
|
||||
|
||||
# Verify
|
||||
A = meanas.fdfd.operators.e_full(omega=omega, dxes=dxes, epsilon=vec(epsilon))
|
||||
b = -1j * omega * vec(J) #* numpy.exp(1j * dt / 2 * omega)
|
||||
c = A @ vec(eph)
|
||||
logger.info('FWD inaccuracy: |Ax-b|/|b| = {}'.format(norm(c-b) / norm(b)))
|
||||
normdiv = norm(b) / norm(c)
|
||||
logger.info(f'{normdiv=}')
|
||||
logger.info('FWD renormed inaccuracy: |Ax-b|/|b| = {}'.format(norm(c * normdiv - b) / norm(b)))
|
||||
|
||||
b = -1j * omega * vec(J)
|
||||
logger.info('FWD base inaccuracy: |Ax-b|/|b| = {}'.format(norm(c-b) / norm(b)))
|
||||
|
||||
from scipy.optimize import minimize
|
||||
def resid(x):
|
||||
b = -1j * omega * vec(J) * numpy.exp(1j * dt * x * omega)
|
||||
return norm(c - b) / norm(b)
|
||||
print('min', minimize(resid, 0.25, options={'xatol': 1e-14, 'fatol': 1e-14}))
|
||||
|
||||
# fig, ax, anim = plot_movie(mov, balanced=True, interval=300)
|
||||
# anim.save('output.mp4')
|
||||
|
||||
print('solving...')
|
||||
cdxes = copy.deepcopy(dxes)
|
||||
for axis in range(3):
|
||||
thickness = pml[axis]
|
||||
if not thickness:
|
||||
continue
|
||||
for pp, polarity in enumerate((-1, 1)):
|
||||
print(axis, polarity, thickness)
|
||||
cdxes = fdfd.scpml.stretch_with_scpml(cdxes, axis=axis, polarity=polarity,
|
||||
omega=omega, epsilon_effective=1.0**2,
|
||||
thickness=thickness)
|
||||
eph2v = meanas.fdfd.solvers.generic(
|
||||
omega=omega, dxes=cdxes, J=vec(J), epsilon=vec(epsilon),
|
||||
matrix_solver_opts={'atol': 1e-3, 'tol': 1e-3, 'x0': vec(eph)})
|
||||
eph2 = unvec(eph2v)
|
||||
|
||||
pyplot.figure()
|
||||
pyplot.pcolormesh(numpy.abs(eph/eph2)[1, 11:-11, 0, 11:-11].real.T)
|
||||
pyplot.colorbar()
|
||||
pyplot.title('mag')
|
||||
pyplot.figure()
|
||||
pyplot.pcolormesh(numpy.angle(eph/eph2)[1, 11:-11, 0, 11:-11].real.T)
|
||||
pyplot.colorbar()
|
||||
pyplot.title('angle')
|
||||
pyplot.show()
|
||||
breakpoint()
|
||||
|
||||
|
||||
import matplotlib
|
||||
from matplotlib import cycler, animation, colors, ticker, pyplot
|
||||
|
||||
def set_pyplot_cycle() -> None:
|
||||
pyplot.rc('lines', linewidth=2.5)
|
||||
pyplot.rc('axes', prop_cycle(
|
||||
cycler('color', 'krbgcm')
|
||||
* cycler('linestyle', ['-', '--', ':', '-.'])
|
||||
))
|
||||
|
||||
|
||||
def pcm(x, y, z, pca={}, cba={}, bare=False, eq=True) -> Tuple:
|
||||
z = numpy.array(z)
|
||||
|
||||
if numpy.any(z < 0):
|
||||
vmax = numpy.abs(z).max()
|
||||
pcolor_args = {'vmin': -vmax, 'vmax': vmax, 'cmap': 'seismic', **pca}
|
||||
else:
|
||||
pcolor_args = {'cmap': 'seismic', **pca}
|
||||
|
||||
xe = centers2edges(x)
|
||||
ye = centers2edges(y)
|
||||
|
||||
if bare:
|
||||
fig = pyplot.gcf()
|
||||
ax = pyplot.gca()
|
||||
else:
|
||||
fig, ax = pyplot.subplot()
|
||||
|
||||
im = ax.pcolormesh(xe, ye, z.T, **pcolor_args)
|
||||
if eq:
|
||||
ax.set_aspect('equal', adjustable='box')
|
||||
|
||||
if not bare:
|
||||
ax.format_coord = lambda xx, yy: format_coord(xx, yy, xe, ye, z.T)
|
||||
fig.colorbar(im, ax=ax, **cba)
|
||||
|
||||
return fig, ax, im
|
||||
|
||||
|
||||
def pcc(x, y, z, cfa={}, cba={}, n_levels: int = 15, bare: bool = False, eq: bool = True) -> Tuple:
|
||||
z = numpy.array(z)
|
||||
|
||||
if numpy.any(z < 0):
|
||||
vmax = numpy.abs(z).max()
|
||||
pcolor_args = {'vmin': -vmax, 'vmax': vmax, 'cmap': 'seismic', **cfa}
|
||||
else:
|
||||
pcolor_args = {'cmap': 'hot', **cfa}
|
||||
|
||||
xe = centers2edges(x)
|
||||
ye = centers2edges(y)
|
||||
|
||||
if bare:
|
||||
fig = pyplot.gcf()
|
||||
ax = pyplot.gca()
|
||||
else:
|
||||
fig, ax = pyplot.subplot()
|
||||
|
||||
levels = ticker.MaxNLocator(nbins=n_levels).tick_values(z.min(), z.max())
|
||||
cmap = pyplot.get_cmap(pcolor_args['cmap'])
|
||||
norm = color.BoundaryNorm(levels, ncolors=cmap.N, clip=True)
|
||||
|
||||
im = ax.contourf(x, y, z.T, levels=levels, **pcolor_args)
|
||||
if eq:
|
||||
ax.set_aspect('equal', adjustable='box')
|
||||
|
||||
if not bare:
|
||||
ax.format_coord = lambda xx, yy: format_coord(xx, yy, xe, ye, z.T)
|
||||
fig.colorbar(im, ax=ax, **cba)
|
||||
|
||||
return fig, ax, im
|
||||
|
||||
|
||||
def centers2edges(centers):
|
||||
d = numpy.diff(centers) / 2
|
||||
e = numpy.hstack((centers[0] - d[0], centers[:-1] + d, centers[-1] + d[-1]))
|
||||
return e
|
||||
|
||||
|
||||
def format_coord(x, y, xs, ys, vs):
|
||||
col = numpy.digitize(x, xs)
|
||||
row = numpy.digitize(y, ys)
|
||||
if 0 < row <= vs.shape[0] and 0 < col <= vs.shape[1]:
|
||||
z = vs[row - 1, col - 1]
|
||||
return f'x={x:1.4g}, y={y:1.4g}, z={z:1.4g}'
|
||||
else:
|
||||
return f'x={x:1.4g}, y={y:1.4g}'
|
||||
|
||||
|
||||
def plot_movie(arr, balanced=True, interval=300, pca={}):
|
||||
if balanced:
|
||||
vmax = numpy.abs(arr).max()
|
||||
pcolor_args = {'vmin': -vmax, 'vmax': vmax, 'cmap': 'seismic', **pca}
|
||||
else:
|
||||
pcolor_args = {'cmap': 'seismic', **pca}
|
||||
|
||||
fig, ax = pyplot.subplots()
|
||||
im = ax.pcolormesh(arr[0, :, :].T, **pcolor_args)
|
||||
ax.set_aspect('equal', adjustable='box')
|
||||
|
||||
def animate(ii):
|
||||
im.set_array(arr[ii, :, :].T.ravel())
|
||||
|
||||
anim = animation.FuncAnimation(fig, animate, frames=arr.shape[0], repeat=True, interval=interval)
|
||||
return fig, im, anim
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run()
|
||||
121
test_test.py
Normal file
121
test_test.py
Normal file
@ -0,0 +1,121 @@
|
||||
import logging
|
||||
import meanas
|
||||
from meanas.fdfd.scpml import stretch_with_scpml
|
||||
from meanas.fdfd.solvers import generic
|
||||
from meanas.fdtd.misc import gaussian_beam
|
||||
from meanas.fdmath import vec
|
||||
from gridlock import Grid
|
||||
import numpy
|
||||
from numpy import pi
|
||||
from matplotlib import pyplot, colors
|
||||
|
||||
|
||||
logging.basicConfig(level=logging.DEBUG)
|
||||
logger = logging.getLogger(__name__)
|
||||
for mm in ('matplotlib', 'PIL'):
|
||||
logging.getLogger(mm).setLevel(logging.WARNING)
|
||||
|
||||
|
||||
wl = 1310
|
||||
omega = 2 * pi / wl
|
||||
eps_bg = 1.45
|
||||
|
||||
grid = Grid([
|
||||
numpy.arange(-20e3, 20e3 + 1, 10),
|
||||
[-1, 1],
|
||||
numpy.arange(-1e3, 1e3 + 1, 10),
|
||||
])
|
||||
|
||||
logger.info(grid.shape)
|
||||
def unvec(vv):
|
||||
return meanas.fdmath.unvec(vv, grid.shape)
|
||||
|
||||
eps = grid.allocate(eps_bg)
|
||||
dxes = [grid.dxyz, grid.autoshifted_dxyz()]
|
||||
|
||||
xx, yy, zz = grid.shifted_xyz(1)
|
||||
print(zz.min(), zz.max(), zz[-25])
|
||||
gauss0 = gaussian_beam(xyz=[xx[12:-12], yy, zz], center=[0, 0, zz[-25]], w0=4600, tilt=numpy.deg2rad(-10), wl=wl / eps_bg)
|
||||
|
||||
e_gauss = numpy.zeros_like(eps, dtype=complex)
|
||||
e_gauss[1, 12:-12, :, :] = gauss0
|
||||
mask = numpy.zeros_like(eps)
|
||||
mask[..., :-25] = 1
|
||||
|
||||
fig, ax = pyplot.subplots()
|
||||
mb = ax.pcolormesh(mask[0, :, 0, :].T, cmap='hot')
|
||||
fig.colorbar(mb)
|
||||
ax.set_aspect('equal')
|
||||
ax.set_title('mask')
|
||||
|
||||
fig, ax = pyplot.subplots()
|
||||
mb = ax.pcolormesh((e_gauss * mask)[1, :, 0, :].real.T, cmap='bwr', norm=colors.CenteredNorm())
|
||||
fig.colorbar(mb)
|
||||
ax.set_aspect('equal')
|
||||
ax.set_title('e_masked')
|
||||
|
||||
pyplot.show()
|
||||
|
||||
vecJ = meanas.fdfd.operators.e_boundary_source(mask=vec(mask), omega=omega, dxes=dxes, epsilon=vec(eps)) @ vec(e_gauss)
|
||||
J = unvec(vecJ)
|
||||
|
||||
for pp in (-1, +1):
|
||||
for aa in (0, 2):
|
||||
dxes = stretch_with_scpml(
|
||||
dxes=dxes,
|
||||
axis=aa,
|
||||
polarity=pp,
|
||||
omega=omega,
|
||||
thickness=10,
|
||||
)
|
||||
|
||||
vecE = generic(omega=omega, dxes=dxes, J=vec(J), epsilon=vec(eps))
|
||||
vecH = meanas.fdfd.operators.e2h(omega=omega, dxes=dxes) @ vecE
|
||||
vecS = meanas.fdfd.operators.poynting_e_cross(e=vecE, dxes=dxes) @ vecH.conj()
|
||||
|
||||
E = unvec(vecE)
|
||||
H = unvec(vecH)
|
||||
S = unvec(vecS)
|
||||
dxs, dys, dzs = grid.dxyz
|
||||
EJ = (-E * J.conj()).sum(axis=0) * dxs[:, None, None] * dys[None, : None] * dzs[None, None, :]
|
||||
P_in = EJ.sum().real / 2
|
||||
|
||||
logger.info(f'P_in = {EJ.sum() / 2:3g}')
|
||||
|
||||
planes = numpy.array([
|
||||
-S[0, 11, :, :].sum(),
|
||||
S[0, -11, :, :].sum(),
|
||||
-S[2, :, :, 11].sum(),
|
||||
S[2, :, :, -11].sum(),
|
||||
]) / 2 / P_in
|
||||
|
||||
logger.info(f'{planes=}')
|
||||
logger.info(f'{planes.sum().real}')
|
||||
|
||||
|
||||
fig, ax = pyplot.subplots()
|
||||
e2 = (E * E.conj() * eps).real.sum(axis=0)
|
||||
mb = ax.pcolormesh(e2[:, 0, :].T / P_in, cmap='hot', norm=colors.LogNorm(vmin=e2.max() / 1e10))
|
||||
fig.colorbar(mb)
|
||||
ax.set_aspect('equal')
|
||||
ax.set_title('E^2 * eps')
|
||||
|
||||
fig, ax = pyplot.subplots()
|
||||
mb = ax.pcolormesh(S[0, :, 0, :].real.T / 2 / P_in, cmap='bwr', norm=colors.CenteredNorm())
|
||||
fig.colorbar(mb)
|
||||
ax.set_aspect('equal')
|
||||
ax.set_title('Sx')
|
||||
|
||||
fig, ax = pyplot.subplots()
|
||||
mb = ax.pcolormesh(S[2, :, 0, :].real.T / 2 / P_in, cmap='bwr', norm=colors.CenteredNorm())
|
||||
fig.colorbar(mb)
|
||||
ax.set_aspect('equal')
|
||||
ax.set_title('Sz')
|
||||
|
||||
fig, ax = pyplot.subplots()
|
||||
mb = ax.pcolormesh(EJ[:, 0, :].real.T / 2 / P_in, cmap='bwr', norm=colors.CenteredNorm())
|
||||
fig.colorbar(mb)
|
||||
ax.set_aspect('equal')
|
||||
ax.set_title('-E.J')
|
||||
|
||||
pyplot.show()
|
||||
Loading…
x
Reference in New Issue
Block a user