def get_sparameters_path(
component: Component,
layer_to_material: Dict[Tuple[int, int], str],
layer_to_thickness: Dict[Tuple[int, int], int],
dirpath: Path = CONFIG["sparameters"],
**kwargs,
) -> Path:
"""Returns Sparameters filepath.
it only includes the layers that are present in the component
Args:
component:
dirpath
layer_to_material: GDSlayer to material alias
layer_to_thickness: GDSlayer to thickness (nm)
"""
dirpath = pathlib.Path(dirpath)
dirpath = (dirpath / component.function_name if hasattr(
component, "function_name") else dirpath)
dirpath.mkdir(exist_ok=True, parents=True)
material_to_thickness = {
layer_to_material[layer]: layer_to_thickness[layer]
for layer in layer_to_thickness.keys()
if tuple(layer) in component.get_layers()
}
material_to_thickness.update(**kwargs)
suffix = get_name_short(dict2name(**material_to_thickness))
return dirpath / f"{component.name}_{suffix}.dat"
def get_simulation(
component: Component,
extend_ports_length: Optional[float] = 4.0,
layer_stack: LayerStack = LAYER_STACK,
res: int = 20,
t_clad_top: float = 1.0,
t_clad_bot: float = 1.0,
tpml: float = 1.0,
clad_material: str = "SiO2",
is_3d: bool = False,
wl_min: float = 1.5,
wl_max: float = 1.6,
wl_steps: int = 50,
dfcen: float = 0.2,
port_source_name: str = 1,
port_field_monitor_name: str = 2,
port_margin: float = 0.5,
distance_source_to_monitors: float = 0.2,
) -> Dict[str, Any]:
"""Returns Simulation dict from gdsfactory.component
based on meep directional coupler example
https://meep.readthedocs.io/en/latest/Python_Tutorials/GDSII_Import/
https://support.lumerical.com/hc/en-us/articles/360042095873-Metamaterial-S-parameter-extraction
Args:
component: gf.Component
extend_ports_function: function to extend the ports for a component to ensure it goes beyond the PML
layer_to_thickness: Dict of layer number (int, int) to thickness (um)
res: resolution (pixels/um) For example: (10: 100nm step size)
t_clad_top: thickness for cladding above core
t_clad_bot: thickness for cladding below core
tpml: PML thickness (um)
clad_material: material for cladding
is_3d: if True runs in 3D
wavelengths: iterable of wavelengths to simulate
dfcen: delta frequency
sidewall_angle: in degrees
port_source_name: input port name
port_field_monitor_name:
port_margin: margin on each side of the port
distance_source_to_monitors: in (um) source goes before
Returns:
sim: simulation object
Make sure you visualize the simulation region with gf.before you simulate a component
.. code::
import gdsfactory as gf
import gmeep as gm
c = gf.components.bend_circular()
margin = 2
cm = gm.add_monitors(c)
gf.show(cm)
"""
layer_to_thickness = layer_stack.get_layer_to_thickness()
layer_to_material = layer_stack.get_layer_to_material()
layer_to_zmin = layer_stack.get_layer_to_zmin()
layer_to_sidewall_angle = layer_stack.get_layer_to_sidewall_angle()
wavelengths = np.linspace(wl_min, wl_max, wl_steps)
if port_source_name not in component.ports:
warnings.warn(
f"port_source_name={port_source_name} not in {component.ports.keys()}"
)
port_source = component.get_ports_list()[0]
port_source_name = port_source.name
warnings.warn(f"Selecting port_source_name={port_source_name} instead.")
if port_field_monitor_name not in component.ports:
warnings.warn(
f"port_field_monitor_name={port_field_monitor_name} not in {component.ports.keys()}"
)
port_field_monitor = (
component.get_ports_list()[0]
if len(component.ports) < 2
else component.get_ports_list()[1]
)
port_field_monitor_name = port_field_monitor.name
warnings.warn(
f"Selecting port_field_monitor_name={port_field_monitor_name} instead."
)
assert isinstance(
component, Component
), f"component needs to be a gf.Component, got Type {type(component)}"
component_extended = (
gf.components.extension.extend_ports(
component=component, length=extend_ports_length, centered=True
)
if extend_ports_length
else component
)
component = component.ref()
component.x = 0
component.y = 0
gf.show(component_extended)
component_extended.flatten()
component_extended = component_extended.ref()
# geometry_center = [component_extended.x, component_extended.y]
# geometry_center = [0, 0]
# print(geometry_center)
layers_thickness = [
layer_to_thickness[layer]
for layer in component.get_layers()
if layer in layer_to_thickness
]
t_core = max(layers_thickness)
cell_thickness = tpml + t_clad_bot + t_core + t_clad_top + tpml if is_3d else 0
cell_size = mp.Vector3(
component.xsize + 2 * tpml,
component.ysize + 2 * tpml,
cell_thickness,
)
geometry = []
layer_to_polygons = component_extended.get_polygons(by_spec=True)
for layer, polygons in layer_to_polygons.items():
if layer in layer_to_thickness and layer in layer_to_material:
height = layer_to_thickness[layer] if is_3d else mp.inf
zmin_um = layer_to_zmin[layer] if is_3d else 0
# center = mp.Vector3(0, 0, (zmin_um + height) / 2)
for polygon in polygons:
vertices = [mp.Vector3(p[0], p[1], zmin_um) for p in polygon]
material_name = layer_to_material[layer]
material = get_material(name=material_name)
geometry.append(
mp.Prism(
vertices=vertices,
height=height,
sidewall_angle=layer_to_sidewall_angle[layer],
material=material,
# center=center
)
)
freqs = 1 / wavelengths
fcen = np.mean(freqs)
frequency_width = dfcen * fcen
# Add source
port = component.ports[port_source_name]
angle = port.orientation
width = port.width + 2 * port_margin
size_x = width * abs(np.sin(angle * np.pi / 180))
size_y = width * abs(np.cos(angle * np.pi / 180))
size_x = 0 if size_x < 0.001 else size_x
size_y = 0 if size_y < 0.001 else size_y
size_z = cell_thickness - 2 * tpml if is_3d else 20
size = [size_x, size_y, size_z]
center = port.center.tolist() + [0] # (x, y, z=0)
field_monitor_port = component.ports[port_field_monitor_name]
field_monitor_point = field_monitor_port.center.tolist() + [0] # (x, y, z=0)
sources = [
mp.EigenModeSource(
src=mp.GaussianSource(fcen, fwidth=frequency_width),
size=size,
center=center,
eig_band=1,
eig_parity=mp.NO_PARITY if is_3d else mp.EVEN_Y + mp.ODD_Z,
eig_match_freq=True,
)
]
sim = mp.Simulation(
resolution=res,
cell_size=cell_size,
boundary_layers=[mp.PML(tpml)],
sources=sources,
geometry=geometry,
default_material=get_material(name=clad_material),
# geometry_center=geometry_center,
)
# Add port monitors dict
monitors = {}
for port_name in component.ports.keys():
port = component.ports[port_name]
angle = port.orientation
width = port.width + 2 * port_margin
size_x = width * abs(np.sin(angle * np.pi / 180))
size_y = width * abs(np.cos(angle * np.pi / 180))
size_x = 0 if size_x < 0.001 else size_x
size_y = 0 if size_y < 0.001 else size_y
size = mp.Vector3(size_x, size_y, size_z)
size = [size_x, size_y, size_z]
# if monitor has a source move monitor inwards
length = -distance_source_to_monitors if port_name == port_source_name else 0
xy_shifted = move_polar_rad_copy(
np.array(port.center), angle=angle * np.pi / 180, length=length
)
center = xy_shifted.tolist() + [0] # (x, y, z=0)
m = sim.add_mode_monitor(freqs, mp.ModeRegion(center=center, size=size))
m.z = 0
monitors[port_name] = m
return dict(
sim=sim,
cell_size=cell_size,
freqs=freqs,
monitors=monitors,
sources=sources,
field_monitor_point=field_monitor_point,
port_source_name=port_source_name,
)
def get_simulation(
component: Component,
mode_index: int = 0,
n_modes: int = 2,
port_extension: Optional[float] = 4.0,
layer_stack: LayerStack = LAYER_STACK,
zmargin: float = 1.0,
thickness_pml: float = 1.0,
clad_material: str = "SiO2",
port_source_name: str = "o1",
port_margin: float = 0.5,
distance_source_to_monitors: float = 0.2,
mesh_step: float = 40e-3,
wavelength: float = 1.55,
) -> td.Simulation:
"""Returns Simulation object from gdsfactory.component
based on GDS example
https://simulation.cloud/docs/html/examples/ParameterScan.html
Args:
component: gf.Component
mode_index: mode index
n_modes: number of modes
port_extension: extend ports beyond the PML
layer_stack: contains layer numbers (int, int) to thickness, zmin
zmargin: thickness for cladding above and below core
thickness_pml: PML thickness (um)
clad_material: material for cladding
port_source_name: input port name
port_margin: margin on each side of the port
distance_source_to_monitors: in (um) source goes before monitors
mesh_step: in all directions
wavelength: in (um)
You can visualize the simulation with gdsfactory
.. code::
import matplotlib.pyplot as plt
import gdsfactory as gf
import gdsfactory.simulation.tidy3d as gm
c = gf.components.bend_circular()
sim = gm.get_simulation(c)
gm.plot_simulation(sim)
"""
layer_to_thickness = layer_stack.get_layer_to_thickness()
layer_to_material = layer_stack.get_layer_to_material()
layer_to_zmin = layer_stack.get_layer_to_zmin()
# layer_to_sidewall_angle = layer_stack.get_layer_to_sidewall_angle()
assert isinstance(
component, Component
), f"component needs to be a gf.Component, got Type {type(component)}"
if port_source_name not in component.ports:
warnings.warn(
f"port_source_name={port_source_name} not in {component.ports.keys()}"
)
port_source = component.get_ports_list()[0]
port_source_name = port_source.name
warnings.warn(
f"Selecting port_source_name={port_source_name} instead.")
component_extended = (gf.components.extension.extend_ports(
component=component, length=port_extension, centered=True)
if port_extension else component)
gf.show(component_extended)
component_extended.flatten()
component_extended_ref = component_extended.ref()
component_ref = component.ref()
component_ref.x = 0
component_ref.y = 0
structures = [
td.Box(
material=get_material(name=clad_material),
size=(td.inf, td.inf, td.inf),
center=(0, 0, 0),
)
]
layers_thickness = [
layer_to_thickness[layer] for layer in component.get_layers()
if layer in layer_to_thickness
]
t_core = max(layers_thickness)
cell_thickness = thickness_pml + t_core + thickness_pml + 2 * zmargin
sim_size = [
component_ref.xsize + 2 * thickness_pml,
component_ref.ysize + 2 * thickness_pml,
cell_thickness,
]
for layer in component.layers:
if layer in layer_to_thickness and layer in layer_to_material:
height = layer_to_thickness[layer]
zmin = layer_to_zmin[layer]
z_cent = zmin + height / 2
material_name = MATERIAL_NAME_TO_TIDY3D[layer_to_material[layer]]
material = get_material(name=material_name)
geometry = td.GdsSlab(
material=material,
gds_cell=component_extended_ref,
gds_layer=layer[0],
gds_dtype=layer[1],
z_cent=z_cent,
z_size=height,
)
structures.append(geometry)
# Add source
port = component_ref.ports[port_source_name]
angle = port.orientation
width = port.width + 2 * port_margin
size_x = width * abs(np.sin(angle * np.pi / 180))
size_y = width * abs(np.cos(angle * np.pi / 180))
size_x = 0 if size_x < 0.001 else size_x
size_y = 0 if size_y < 0.001 else size_y
size_z = cell_thickness - 2 * thickness_pml
size = [size_x, size_y, size_z]
center = port.center.tolist() + [0] # (x, y, z=0)
freq0 = td.constants.C_0 / wavelength
fwidth = freq0 / 10
msource = td.ModeSource(
size=size,
center=center,
source_time=td.GaussianPulse(frequency=freq0, fwidth=fwidth),
direction="forward",
)
# Add port monitors
monitors = {}
ports = sort_ports_x(sort_ports_y(component_ref.get_ports_list()))
for port in ports:
port_name = port.name
angle = port.orientation
width = port.width + 2 * port_margin
size_x = width * abs(np.sin(angle * np.pi / 180))
size_y = width * abs(np.cos(angle * np.pi / 180))
size_x = 0 if size_x < 0.001 else size_x
size_y = 0 if size_y < 0.001 else size_y
size = (size_x, size_y, size_z)
# if monitor has a source move monitor inwards
length = -distance_source_to_monitors if port_name == port_source_name else 0
xy_shifted = move_polar_rad_copy(np.array(port.center),
angle=angle * np.pi / 180,
length=length)
center = xy_shifted.tolist() + [0] # (x, y, z=0)
monitors[port_name] = td.ModeMonitor(
center=[port.x, port.y, t_core / 2],
size=size,
freqs=[freq0],
Nmodes=1,
name=port.name,
)
domain_monitor = td.FreqMonitor(center=[0, 0, z_cent],
size=[sim_size[0], sim_size[1], 0],
freqs=[freq0])
sim = td.Simulation(
size=sim_size,
mesh_step=mesh_step,
structures=structures,
sources=[msource],
monitors=[domain_monitor] + list(monitors.values()),
run_time=20 / fwidth,
pml_layers=[12, 12, 12],
)
# set the modes
sim.compute_modes(msource, Nmodes=n_modes)
sim.set_mode(msource, mode_ind=mode_index)
return sim
