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, )