def option2():
"""not recommended"""
r = 0.1
c2 = gf.components.circle(radius=r, angle_resolution=2, layer=(1, 0))
gdspath1 = c2.write_gds(
precision=1e-9
) # 1nm is the default precision for most Photonics fabs
gf.show(gdspath1)
gdspath2 = c2.write_gds(
precision=10e-12
) # you can also increase to 10pm resolution
gf.show(gdspath2)
def _demo_netlist():
"""path on the route"""
import gdsfactory as gf
# c = from_yaml(sample_2x2_connections)
c = from_yaml(sample_waypoints)
c = from_yaml(sample_different_factory)
c.show()
full_settings = True
n = c.get_netlist(full_settings=full_settings)
yaml_str = OmegaConf.to_yaml(n, sort_keys=True)
c2 = from_yaml(yaml_str)
n2 = c2.get_netlist(full_settings=full_settings)
d = jsondiff.diff(n, n2)
assert len(d) == 0
gf.show(c2)
# add source
component_with_source = add_monitors_and_extend_ports(
component_with_monitors,
extension_length=extension_length,
port_labels=[source_port_name],
layer=layer_source,
)
# add simulation region
component_with_padding = gf.add_padding(
component=component_with_source,
default=0,
layers=[layer_simulation_region],
top=top,
bottom=bottom,
right=right,
left=left,
)
c.add(component_with_padding)
c.ports = component_with_padding.ports
return c
if __name__ == "__main__":
gdspath = pathlib.Path.cwd() / "waveguide.gds"
c = gf.components.bend_circular(radius=5)
# c = gf.components.waveguide(length=2)
# cm = extend_ports(component=c)
cm = add_monitors(component=c)
gf.show(cm)
doe_name="width_length",
width_mmi=[5, 10],
length_mmi=[20, 30],
do_permutations=False,
)
assert len(paths) == 2
paths = write_sweep(
component_type="mmi1x2",
doe_name="width_length2",
width_mmi=[5, 10],
length_mmi=[20, 30],
do_permutations=True,
doe_settings=dict(test="optical_tm"),
)
assert len(paths) == 4
return paths[0]
if __name__ == "__main__":
import gdsfactory as gf
path0 = test_write_sweep()
gf.show(path0)
# print(get_markdown_table(width_mmi=[5, 6]))
# paths = write_doe(
# "mmi1x2", width_mmi=[5, 10], length_mmi=[20, 30], do_permutations=False
# )
# print(paths)
# gdspaths = test_write_doe()
def show(filename: str) -> None:
"""Show a GDS file using klive"""
gdsfactory.show(filename)
ignore_angle_deg,
min_projection,
max_projection,
)
# print(d.polygons().area())
return d.polygons().area()
if __name__ == "__main__":
import gdsfactory as gf
space = 0.12
min_space = 0.1
dbu = 1000
layer = gf.LAYER.WG
gdspath = gf.components.straight_array(spacing=space)
gf.show(gdspath)
if isinstance(gdspath, Component):
gdspath.flatten()
gdspath = gdspath.write_gds()
layout = pya.Layout()
layout.read(str(gdspath))
cell = layout.top_cell()
region = pya.Region(cell.begin_shapes_rec(layout.layer(layer[0],
layer[1])))
print(region.corners().area())
metrics = "Square"
metrics = getattr(pya.Region, metrics)
d = region.space_check(min_space * dbu, False, metrics, 80, None, None)
"""Group references. Distribute them ...
"""
if __name__ == "__main__":
import gdsfactory as gf
D = gf.Component()
t1 = D << gf.components.text("1")
t2 = D << gf.components.text("2")
t3 = D << gf.components.text("3")
t4 = D << gf.components.text("4")
t5 = D << gf.components.text("5")
t6 = D << gf.components.text("6")
D.distribute(direction="x", spacing=3)
gf.show(D)
port=Port(
name=p.name,
midpoint=p.midpoint,
width=p.width,
orientation=p.orientation,
parent=p.parent,
)
)
for poly in device.polygons:
component.add_polygon(poly)
for label in device.labels:
component.add_label(
text=label.text,
position=label.position,
layer=(label.layer, label.texttype),
)
return component
if __name__ == "__main__":
import phidl.geometry as pg
import gdsfactory as gf
c = pg.rectangle()
c = pg.snspd()
c2 = from_phidl(component=c)
print(c2.ports)
gf.show(c2)
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
else:
p = _offset_polygons_parallel(
polygons_to_offset,
distance=distance,
num_divisions=num_divisions,
join_first=join_first,
precision=precision,
join=join,
tolerance=tolerance,
)
component = gf.Component("offset")
polygons = component.add_polygon(p, layer=layer)
[
polygon.fracture(max_points=max_points, precision=precision)
for polygon in polygons
]
return component
def test_offset():
c = gf.components.ring()
co = offset(c, distance=0.5)
assert int(co.area()) == 94
if __name__ == "__main__":
c = gf.components.ring()
co = offset(c, distance=0.5)
gf.show(co)
precision=precision,
doe_root_path=doe_root_path,
doe_metadata_path=doe_metadata_path,
cache=True,
)
top_level = place_from_yaml(does_yml,
precision=precision,
root_does=doe_root_path)
top_level.write(str(gdspath))
tm = merge_metadata(gdspath)
test_protocol_path.write_text(OmegaConf.to_yaml(tm))
assert gdspath.exists()
return gdspath
if __name__ == "__main__":
# gdspath_mask = test_mask()
# gf.show(gdspath_mask)
# c = coupler_te(gap=0.3, length=2.0)
# c = spiral_te(length=60e3)
# c.show()
# lengths = [18.24, 36.48, 54.72, 72.96, 91.2]
# for length in lengths:
# c = coupler_te(gap=0.3, length=length)
gds = test_mask()
gf.show(gds)
def demo_netlist(component_type):
c1 = factory[component_type]()
n = c1.get_netlist()
yaml_str = OmegaConf.to_yaml(n, sort_keys=True)
c2 = gf.read.from_yaml(yaml_str)
gf.show(c2)
c2.add_port(
name=port,
midpoint=[port_loc[0], port_loc[1]],
width=po.wgt.wg_width,
orientation=direction,
layer=port_layer,
)
c2.absorb(ref)
c2.auto_rename_ports()
return c2
if __name__ == "__main__":
wgt = pc.WaveguideTemplate(
bend_radius=50.0,
wg_width=1.0,
wg_layer=1,
wg_datatype=0,
clad_layer=2,
clad_datatype=0,
)
# gc = pc.GratingCoupler(wgt, port=(10, 20), direction=np.pi * 7 / 8)
gc = pc.GratingCoupler(wgt, port=(10, 20), direction=0.0)
gcc = from_picwriter(gc)
gf.show(gcc)
build_path = cwd / "build"
doe_root_path = cwd / "build" / "cache_doe_directory"
mask_path = cwd / "build" / "mask"
gdspath = mask_path / "mask.gds"
logpath = gdspath.with_suffix(".log")
mask_path.mkdir(parents=True, exist_ok=True)
shutil.rmtree(build_path, ignore_errors=True)
logger.add(sink=logpath)
write_sweeps(
str(does_path),
doe_root_path=doe_root_path,
)
top_level = place_from_yaml(does_path, root_does=doe_root_path)
top_level.write(str(gdspath))
merge_metadata(gdspath)
assert gdspath.exists()
return gdspath
if __name__ == "__main__":
c = get_mask()
gf.show(c)
cwd = pathlib.Path(__file__).absolute().parent
does_path = cwd / "does.yml"
build_path = cwd / "build"
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,
)
import gdsfactory as gf
from gdsfactory.gdsdiff.gdsdiff import gdsdiff
if __name__ == "__main__":
c1 = gf.components.mmi1x2(length_mmi=5)
c2 = gf.components.mmi1x2(length_mmi=9)
c3 = gdsdiff(c1, c2)
gf.show(c3)
def get_simulation(
component: Component,
resolution: int = 20,
extend_ports_length: Optional[float] = 10.0,
layer_stack: LayerStack = LAYER_STACK,
zmargin_top: float = 3.0,
zmargin_bot: float = 3.0,
tpml: float = 1.5,
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 = "o1",
port_field_monitor_name: str = "o2",
port_margin: float = 3,
distance_source_to_monitors: float = 0.2,
port_source_offset: float = 0,
port_monitor_offset: float = 0,
dispersive: bool = False,
**settings,
) -> Dict[str, Any]:
r"""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
.. code::
top view
________________________________
| |
| xmargin_left | port_extension
|<------> port_margin ||<-->
___|___________ _________||___
| \ / |
| \ / |
| ====== |
| / \ |
___|___________/ \__________|___
| | <-------->|
| |ymargin_bot xmargin_right|
| | |
|___|___________________________|
side view
________________________________
| | |
| | |
| zmargin_top |
|ymargin | |
|<---> _____ _|___ |
| | | | | |
| | | | | |
| |_____| |_____| |
| | |
| | |
| |zmargin_bot |
| | |
|_______|_______________________|
Args:
component: gf.Component
resolution: in pixels/um (20: for coarse, 120: for fine)
extend_ports_length: to extend ports beyond the PML
layer_stack: Dict of layer number (int, int) to thickness (um)
zmargin_top: thickness for cladding above core
zmargin_bot: thickness for cladding below core
tpml: PML thickness (um)
clad_material: material for cladding
is_3d: if True runs in 3D
wl_min: wavelength min (um)
wl_max: wavelength max (um)
wl_steps: wavelength steps
dfcen: delta frequency
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
port_source_offset: offset between source GDS port and source MEEP port
port_monitor_offset: offset between monitor GDS port and monitor MEEP port
dispersive: use dispersive material models (requires higher resolution)
Keyword Args:
settings: other parameters for sim object (resolution, symmetries, etc.)
Returns:
simulation dict: sim, monitors, sources
Make sure you review the simulation before you simulate a component
.. code::
import gdsfactory as gf
import gdsfactory.simulation.meep as gm
c = gf.components.bend_circular()
gm.write_sparameters_meep(c, run=False)
"""
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()
component_ref = component.ref()
component_ref.x = 0
component_ref.y = 0
wavelengths = np.linspace(wl_min, wl_max, wl_steps)
port_names = list(component_ref.ports.keys())
if port_source_name not in port_names:
warnings.warn(f"port_source_name={port_source_name!r} not in {port_names}")
port_source = component_ref.get_ports_list()[0]
port_source_name = port_source.name
warnings.warn(f"Selecting port_source_name={port_source_name!r} instead.")
if port_field_monitor_name not in component_ref.ports:
warnings.warn(
f"port_field_monitor_name={port_field_monitor_name!r} not in {port_names}"
)
port_field_monitor = (
component_ref.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!r} 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
)
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.layers
if layer in layer_to_thickness
]
t_core = max(layers_thickness)
cell_thickness = tpml + zmargin_bot + t_core + zmargin_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, dispersive=dispersive)
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_ref.ports[port_source_name]
angle_rad = np.radians(port.orientation)
width = port.width + 2 * port_margin
size_x = width * abs(np.sin(angle_rad))
size_y = width * abs(np.cos(angle_rad))
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]
xy_shifted = move_polar_rad_copy(
np.array(port.center), angle=angle_rad, length=port_source_offset
)
center = xy_shifted.tolist() + [0] # (x, y, z=0)
field_monitor_port = component_ref.ports[port_field_monitor_name]
field_monitor_point = field_monitor_port.center.tolist() + [0] # (x, y, z=0)
if np.isclose(port.orientation, 0):
direction = mp.X
elif np.isclose(port.orientation, 90):
direction = mp.Y
elif np.isclose(port.orientation, 180):
direction = mp.X
elif np.isclose(port.orientation, 270):
direction = mp.Y
else:
ValueError(f"Port angle {port.orientation} not 0, 90, 180, or 270 degrees!")
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,
eig_kpoint=-1 * mp.Vector3(x=1).rotate(mp.Vector3(z=1), angle_rad),
direction=direction,
)
]
sim = mp.Simulation(
cell_size=cell_size,
boundary_layers=[mp.PML(tpml)],
sources=sources,
geometry=geometry,
default_material=get_material(name=clad_material),
resolution=resolution,
**settings,
)
# Add port monitors dict
monitors = {}
for port_name in component_ref.ports.keys():
port = component_ref.ports[port_name]
angle_rad = np.radians(port.orientation)
width = port.width + 2 * port_margin
size_x = width * abs(np.sin(angle_rad))
size_y = width * abs(np.cos(angle_rad))
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 + port_source_offset
if port_name == port_source_name
else port_monitor_offset
)
xy_shifted = move_polar_rad_copy(
np.array(port.center), angle=angle_rad, 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,
initialized=False,
)
