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