import nazca as nd import numpy as np import math from ..structures import * from ..structures import _my_polygon from ..basic import __cell_arg__ from ..routing import Route import pandas as pd ''' Class for nanoantenna ''' class Nano_ant(): """Class of nanoantenna for optical phased array. This is the class of nanoantenna for optical phased array. GDS cell can be generated using this class. Simulation structure generation and simulation results analysis is going to be added in the future. Args: - tapeout [class] (Default: CUMEC_CSiP130Cu) - w_wg [um] (Default: 0.5um) Width of input waveguide - vector [um] (Default: [0.5,..,0.5]]) Vectors to define the length of each teeth - taper_length [um] (Default: 1um) Length of the linear taper region - width [um] (Default: 3um) Width of the nanoantenna - max_theta [degree](Default: 110) Open degree of linear taper - define_type [str] (Default: non-periodic) Way to define the antenna, including: "non-periodic", "periodic" - etch_depth [str] (Default: "DETCH") Define the etch depth, including: "FETCH", "METCH", "SETCH" """ def __init__( self, w_wg: float = 0.41, xs_wg: str = "strip", define_type: str = "non-periodic", vector: float = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5], taper_length: float = 3, width: float = 6, max_theta: float = 110, pitch: float = 0.6, duty_cycle: float = 0.3, teeth_number: float = 6, etch_depth: str = ["METCH"], show_pins: bool = True ): # Init and save the input parameters self.w_wg = w_wg self.xs_wg = xs_wg # Determine the etch type if len(etch_depth)==1: self.etch_type = "single" elif len(etch_depth)==2: self.etch_type = "dual" if define_type=="non-periodic": self.vector = vector self.teeth_number = len(vector)/2 elif define_type=="periodic": # Parameters necessary when the ant is defined by "periodic" way if self.etch_type=="single": self.vector = [pitch*((2*duty_cycle-1)*(index%2)+1-duty_cycle) for index in range(teeth_number*2)] self.pitch = pitch self.duty_cycle = duty_cycle self.teeth_number = teeth_number elif self.etch_type=="dual": self.vector = [ pitch[1]*((2*duty_cycle[1]-1)*(index%2)+1-duty_cycle[1]) for index in range(teeth_number*2) ] self.vector[0] = pitch[0]*(1-duty_cycle[0]) self.vector[1] = pitch[0]*duty_cycle[0] self.pitch = pitch self.duty_cycle = duty_cycle self.teeth_number = teeth_number self.taper_length = taper_length self.ant_length = self.taper_length + sum(self.vector) self.width = width self.max_theta = max_theta self.define_type = define_type # Here, I should change the name-type according to the difinition in the foundry.py self.etch_depth = [] for etch in etch_depth: if etch=="FETCH": self.etch_depth = self.etch_depth+["STRIP"] # self.etch_depth.append("STRIP") elif etch=="METCH": self.etch_depth = self.etch_depth+["RIB"] # self.etch_depth.append("RIB") elif etch=="SETCH": self.etch_depth = self.etch_depth+["SRIB"] # self.etch_depth.append("SRIB") self.show_pins = show_pins self.cell = self.generate_gds() def generate_gds(self, sample_step=0.1, cell_name="Nanoantenna"): with nd.Cell(name=cell_name, instantiate=False) as nano_ant: layer_tre = nd.get_layer("STRIP_TRE") if layer_tre == "STRIP_TRE" : self.generate_gds_positive(sample_step=sample_step) else : ## TO DO self.generate_gds_error() # Add pins nd.Pin(name="a0", width=self.w_wg).put(0, 0, 180) nd.Pin(name="g1", width=self.w_wg).put(0, 0, 180) if self.show_pins: nd.put_stub(pinname="g1") return nano_ant def generate_gds_positive(self, sample_step=0.1): """ Generate a gds cell based on the logic of positive photoresistance. | Positive: Define the etched region using GETCH_TRE layer. """ width_extra_trench = 0.1 theta_rad_max = self.max_theta * math.pi / 180 ## Check if the input is appropriate or not if math.floor(self.teeth_number) != self.teeth_number: print("WARNNING :: Please re-check the vector of your antenna and make sure the length of vector is even.") message = 'Inappropriate Definition of antenna.' nd.text(text=message, height=5, layer=(96, 0), align='cc').put(0, 0) return 0 ## Build the structure # Add input waveguide nd.strt(length=self.taper_length-0.5, width=self.w_wg, xs=self.xs_wg).put(0, 0) # Add the fan polygon region radius_max = self.taper_length + sum(self.vector) if self.width/2 > radius_max: theta_rad = theta_rad_max/2 elif math.asin(self.width/2/radius_max) > theta_rad_max/2: theta_rad = theta_rad_max/2 elif math.asin(self.width/2/radius_max) <= theta_rad_max/2: theta_rad = math.asin(self.width/2/radius_max) theta_list = np.linspace(-theta_rad, theta_rad, math.floor(theta_rad*2*radius_max/sample_step)) fan_polygon = [(radius_max*math.cos(theta), radius_max*math.sin(theta)) for theta in theta_list] # fan_polygon = fan_polygon + [(self.width/2/math.tan(theta_rad_max/2), self.width/2), (0, self.w_wg/2), # (0, -self.w_wg/2), (self.width/2/math.tan(theta_rad_max/2), -self.width/2)] fan_polygon = fan_polygon + [(self.width/2/math.tan(theta_rad_max/2), self.width/2), (0, 0), (self.width/2/math.tan(theta_rad_max/2), -self.width/2)] nd.Polygon(points=fan_polygon, layer="STRIP_COR").put(0, 0) layer_cld = nd.get_layer("STRIP_CLD") if layer_cld == "STRIP_CLD": # Add CLD region if necessary nd.strt(length=self.ant_length+1, width=max(self.width+1, self.w_wg+4), layer=layer_cld).put(0, 0) # Add the teeth radius_cur = self.taper_length for teeth_index in range(0, int(self.teeth_number)): ## Determine the angular region first if teeth_index == 0: radius_ref = radius_cur else: radius_ref = radius_cur + self.vector[teeth_index*2-1] if (self.width+width_extra_trench)/2 > radius_ref: theta_rad = theta_rad_max/2 + width_extra_trench/radius_ref elif math.asin((self.width+width_extra_trench)/2/radius_ref) > theta_rad_max/2: theta_rad = theta_rad_max/2 + width_extra_trench/radius_ref else: theta_rad = math.asin((self.width+width_extra_trench)/2/radius_ref) theta_step = sample_step / radius_ref theta_list = np.linspace(-theta_rad, theta_rad, math.floor(2*theta_rad/theta_step)) ## Construct the inner radius curve if teeth_index == 0: radius_cur = radius_cur else: radius_cur = radius_cur + self.vector[teeth_index*2-1] inner_radius_curve = [(radius_cur*math.cos(theta), radius_cur*math.sin(theta)) for theta in theta_list] ## Construct the outer radius curve radius_cur = radius_cur + self.vector[teeth_index*2] outer_radius_curve = [(radius_cur*math.cos(theta), radius_cur*math.sin(theta)) for theta in theta_list] outer_radius_curve.reverse() ## Add two dummy points to avoid sharp angle offset_length = 0.015 / 2 minimum_etch = 0.2 radius_inner = radius_cur - self.vector[teeth_index*2] radius_outer = radius_inner + self.vector[teeth_index*2] x_1 = radius_inner * math.cos(theta_rad) + offset_length * math.cos(theta_rad) y_1 = radius_inner * math.sin(theta_rad) + offset_length * math.sin(theta_rad) vertical_length = math.sqrt(np.power(minimum_etch, 2) - np.power(offset_length, 2)) dummy1_x = x_1 - vertical_length * math.sin(theta_rad) dummy1_y = y_1 + vertical_length * math.cos(theta_rad) x_2 = radius_outer * math.cos(theta_rad) - offset_length * math.cos(theta_rad) y_2 = radius_outer * math.sin(theta_rad) - offset_length * math.sin(theta_rad) dummy2_x = x_2 - vertical_length * math.sin(theta_rad) dummy2_y = y_2 + vertical_length * math.cos(theta_rad) ## Construct the teeth polygon teeth_polygon = inner_radius_curve+[(dummy1_x,dummy1_y),(dummy2_x,dummy2_y)]+outer_radius_curve+[(dummy2_x, -dummy2_y),(dummy1_x,-dummy1_y)] if self.etch_type == "single": nd.Polygon(points=teeth_polygon, layer=self.etch_depth[0]+"_TRE").put(0, 0) if self.etch_type == "dual": if teeth_index==0: nd.Polygon(points=teeth_polygon, layer=self.etch_depth[0]+"_TRE").put(0, 0) else: nd.Polygon(points=teeth_polygon, layer=self.etch_depth[1]+"_TRE").put(0, 0) def generate_gds_error(self): nd.text(text="This foundry is not compatiable with current device. Please check.", height=10, layer=1001).put(0, 0) ''' Class for 2D antenna array for FMF grating ''' class Taper() : def __init__(self, width1=4, width2=0.45, length=30, type="linear", show_pins=False) -> None: self.width1 = width1 self.width2 = width2 self.length = length self.type = type if self.type == "parabolic" : self.order = 2 elif self.type == "linear" : self.order = 1 self.show_pins = show_pins self.cell = self.generate_gds() def generate_gds(self) : with nd.Cell(name="taper", instantiate=False) as ic : if self.order == 1 : strip = Route(radius=10,width=self.width1,xs='strip') linear_taper = strip.taper( length=self.length,width1=self.width1,width2=self.width2,patch=True).put(0,0,0) output_strt = strip.strt(length=0.5,width=self.width2).put() nd.Pin(name="a1",width=self.width1).put(linear_taper.pin['a0']) nd.Pin(name="b1",width=self.width2).put(output_strt.pin['b0']) else : c2 = self.width1/2 c1 = (c2 - self.width2/2) / np.power(self.length, self.order) x_list = np.linspace(0, self.length, int(np.floor(self.length/0.2))) taper_up_poly = [(x, -c1*np.power(x, self.order)+c2) for x in x_list] taper_down_poly = [(x, -(-c1*np.power(x, self.order)+c2)) for x in x_list] taper_down_poly.reverse() taper_poly = taper_up_poly + taper_down_poly nd.Polygon(points=taper_poly, layer='STRIP_COR').put(0,0) c2 = (self.width1+4)/2 c1 = (c2 - (self.width2+4)/2) / np.power(self.length, self.order) x_list = np.linspace(0, self.length, int(np.floor(self.length/0.2))) taper_up_poly = [(x, -c1*np.power(x, self.order)+c2) for x in x_list] taper_down_poly = [(x, -(-c1*np.power(x, self.order)+c2)) for x in x_list] taper_down_poly.reverse() taper_poly = taper_up_poly + taper_down_poly nd.Polygon(points=taper_poly, layer='STRIP_CLD').put(0,0) width_max = np.max(np.array([self.width1, self.width2])) taper_poly = [ (0, width_max/2+2), (0, -width_max/2-2), (self.length, -width_max/2-2), (self.length, width_max/2+2) ] nd.Polygon(points=taper_poly, layer='STRIP_CLD').put(0,0) nd.strt(length=0.5, width=self.width2, xs='strip').put(self.length,0,0) nd.Pin(name='a1',width=self.width1).put(0,0,180) nd.Pin(name="b1",width=self.width2).put(self.length+0.5,0,0) if self.show_pins : nd.put_stub() return ic class Grating_2D_Hole() : ''' This is a class for 2D Grating in IMEC. ''' def __init__( self, w_wg=0.5, w_gt=5, l_taper=30, type_taper="parabolic", gt_vector=[0.5,0.5,0.5,0.5,0.5,], gt_diameter=0.4, gt_layer="STRIP_COR", polysi_vector=[0.5,0.5,0.5,0.5,0.5], polysi_diameter=0.4, polysi_layer="FCW_TRE", reflector_vector=[0.3,0.3,0.3,0.3,0.3,0.3], l_field_center = 1 ) -> None: self.w_wg = w_wg self.w_gt = w_gt self.l_taper = l_taper self.type_taper = type_taper self.gt_vector = gt_vector self.gt_num = len(self.gt_vector) self.gt_diameter = gt_diameter self.gt_layer =gt_layer self.polysi_vector = polysi_vector self.polysi_num = len(self.polysi_vector) self.polysi_diameter = polysi_diameter self.polysi_layer = polysi_layer self.reflector_vector = reflector_vector self.l_field_center = l_field_center self.cell = self.generate_gds() def generate_gds(self) : with nd.Cell(name="2D_Grating", instantiate=False) as ic : '''Generate the diffraction region first.''' strip_cor_poly = [ (self.w_gt/2, self.w_gt/2), (self.w_gt/2, -self.w_gt/2), (-self.w_gt/2, -self.w_gt/2), (-self.w_gt/2, self.w_gt/2) ] nd.Polygon(points=strip_cor_poly, layer='STRIP_COR').put(0,0,0) strip_cld_poly = [ (self.w_gt/2+2, self.w_gt/2+2), (self.w_gt/2+2, -self.w_gt/2-2), (-self.w_gt/2-2, -self.w_gt/2-2), (-self.w_gt/2-2, self.w_gt/2+2) ] nd.Polygon(points=strip_cld_poly, layer='STRIP_CLD').put(0,0,0) '''Generate the reflection region.''' self.reflector_num = int(len(self.reflector_vector)/2) for index in range(self.reflector_num) : loc = self.w_gt/2 + sum(self.reflector_vector[0:2*index+1]) + self.reflector_vector[2*index+1]/2 nd.strt(length=self.w_gt, width=self.reflector_vector[2*index+1], xs='strip').put( -loc, -(self.w_gt)/2, 90 ) nd.strt(length=self.w_gt, width=self.reflector_vector[2*index+1], xs='strip').put( -(self.w_gt)/2, -loc, 0 ) '''Generate the taper output.''' taper = Taper(width1=self.w_gt, width2=self.w_wg, length=self.l_taper, type=self.type_taper) taper_horizontal = taper.cell.put('a1', self.w_gt/2,0,0) taper_vertical = taper.cell.put('a1',0,self.w_gt/2,90) '''Generate the diffraction etched region.''' theta_list = np.linspace(0, 2*np.pi, 32) gt_ring_poly = [ (self.gt_diameter/2*np.cos(theta), self.gt_diameter/2*np.sin(theta)) for theta in theta_list ] polysi_ring_poly = [ (self.polysi_diameter/2*np.cos(theta), self.polysi_diameter/2*np.sin(theta)) for theta in theta_list ] self._generate_hole_array_( polygon=gt_ring_poly, vector=self.gt_vector, layer=self.gt_layer ).put(self.w_gt/2, self.w_gt/2) self._generate_hole_array_( polygon=polysi_ring_poly, vector=self.polysi_vector, layer=self.polysi_layer ).put(self.w_gt/2, self.w_gt/2) '''Put the pin location''' nd.Pin(name='g1').put(taper_horizontal.pin['b1']) nd.Pin(name='g2').put(taper_vertical.pin['b1']) # nd.put_stub() return ic def _generate_hole_array_(self,polygon,vector,layer) : with nd.Cell(name="diffration_"+layer, instantiate=False) as ic : for lateral_index in range(len(vector)) : for vertical_index in range(len(vector)) : nd.Polygon(points=polygon,layer=layer).put( -sum(vector[0:lateral_index+1]), -sum(vector[0:vertical_index+1]) ) return ic class Grating_2D_Hole_4Rec() : def __init__(self, grating_unit, mode_radius=8, cell_name=None, show_pins=False) -> None: self.gt_2D_class = grating_unit self.cell_unit = grating_unit.cell self.mode_radius = mode_radius # Calculate the field center location # radius = np.sqrt(2)/2 * ( # self.mode_radius + np.sqrt(2)/2*(grating_unit.w_gt/2-grating_unit.l_field_center) - # np.sqrt(np.power(self.mode_radius, 2) - 1/2*np.power(grating_unit.w_gt/2-grating_unit.l_field_center, 2)) # ) # print("---------------------"+str(radius)+"------------------------------") l_field_center = grating_unit.l_field_center w_gt = grating_unit.w_gt x0 = ( 2*(w_gt/2-l_field_center)-np.sqrt( 8*mode_radius**2 - 4 * (w_gt/2 - l_field_center)**2 ) ) / 4 self.field_center = ( x0 + mode_radius*np.cos(np.pi/4), x0 + mode_radius*np.cos(np.pi/4), 180 ) self.cell_unit._put_pin(name='g0', connect=self.field_center) self.show_pins = show_pins self.cell_name = cell_name self.cell = self.generate_gds() def generate_gds(self) : if self.cell_name is not None : self.cell_name = "TwoD_Grating_" + self.cell_name else : self.cell_name = "TwoD_Grating" with nd.Cell(name=self.cell_name, instantiate=False) as ic : gt_1 = self.cell_unit.put( 'g0', self.mode_radius*np.cos(np.pi/4), self.mode_radius*np.sin(np.pi/4) ) gt_2 = self.cell_unit.put( 'g0', self.mode_radius*np.cos(np.pi/4), -self.mode_radius*np.sin(np.pi/4), flip=True ) gt_3 = self.cell_unit.put( 'g0', -self.mode_radius*np.cos(np.pi/4), -self.mode_radius*np.sin(np.pi/4), flip=True, flop=True ) gt_4 = self.cell_unit.put( 'g0', -self.mode_radius*np.cos(np.pi/4), self.mode_radius*np.sin(np.pi/4), flip=False, flop=True ) '''Put OPEN and PATH region if necessary.''' if nd.get_layer(layer="GC_OPEN") == "GC_OPEN" : nd.Polygon( points=nd.geom.circle(radius=self.mode_radius+20, N=int(np.floor((self.mode_radius+20)/0.1))), layer="GC_OPEN" ).put(0,0) if nd.get_layer(layer="STRIP_CLD") == "STRIP_CLD" : nd.Polygon( points=nd.geom.circle(radius=self.mode_radius+10, N=int(np.floor((self.mode_radius+20)/0.1))), layer="STRIP_CLD" ).put(0,0) ''' Put Pins ''' nd.Pin(name='g1').put(gt_1.pin['g1']) nd.Pin(name='g2').put(gt_1.pin['g2']) nd.Pin(name='g3').put(gt_2.pin['g1']) nd.Pin(name='g4').put(gt_2.pin['g2']) nd.Pin(name='g5').put(gt_3.pin['g1']) nd.Pin(name='g6').put(gt_3.pin['g2']) nd.Pin(name='g7').put(gt_4.pin['g1']) nd.Pin(name='g8').put(gt_4.pin['g2']) nd.Pin(name='a0').put(gt_1.pin['g1'].x, 0, 0) if self.show_pins : nd.put_stub() return ic class Grating_2D_Hole_3Rec() : def __init__(self, grating_unit, mode_radius=6.5, cell_name=None, show_pins=False) -> None: self.gt_2D_class = grating_unit self.cell_unit = grating_unit.cell self.mode_radius = mode_radius self.cell_name = cell_name # Calculate the field center location radius = np.sqrt(2)/2 * ( self.mode_radius + np.sqrt(2)/2*(grating_unit.w_gt/2-grating_unit.l_field_center) - np.sqrt(np.power(self.mode_radius, 2) - 1/2*np.power(grating_unit.w_gt/2-grating_unit.l_field_center, 2)) ) self.field_center = ( radius*np.cos(np.pi/4), radius*np.cos(np.pi/4), 45 ) self.cell_unit._put_pin(name='g0', connect=self.field_center) self.show_pins = show_pins self.cell = self.generate_gds() def generate_gds(self) : if self.cell_name is not None : self.cell_name = "TwoD_Grating_" + self.cell_name else : self.cell_name = "TwoD_Grating" with nd.Cell(name=self.cell_name, instantiate=False) as ic : rotation_angle = 2*np.pi/3*0 gt_1 = self.cell_unit.put( 'g0', self.mode_radius*np.cos(rotation_angle), self.mode_radius*np.sin(rotation_angle), 180 + rotation_angle*180/np.pi ) rotation_angle = 2*np.pi/3*1 gt_2 = self.cell_unit.put( 'g0', self.mode_radius*np.cos(rotation_angle), self.mode_radius*np.sin(rotation_angle), 180 + rotation_angle*180/np.pi ) rotation_angle = 2*np.pi/3*2 gt_3 = self.cell_unit.put( 'g0', self.mode_radius*np.cos(rotation_angle), self.mode_radius*np.sin(rotation_angle), 180 + rotation_angle*180/np.pi ) '''Put OPEN and PATH region if necessary.''' if nd.get_layer(layer="GC_OPEN") == "GC_OPEN" : nd.Polygon( points=nd.geom.circle(radius=self.mode_radius+20, N=int(np.floor((self.mode_radius+20)/0.1))), layer="GC_OPEN" ).put(0,0) if nd.get_layer(layer="STRIP_CLD") == "STRIP_CLD" : nd.Polygon( points=nd.geom.circle(radius=self.mode_radius+10, N=int(np.floor((self.mode_radius+20)/0.1))), layer="STRIP_CLD" ).put(0,0) '''Put pins''' nd.Pin(name='g1').put(gt_1.pin['g1']) nd.Pin(name='g2').put(gt_1.pin['g2']) nd.Pin(name='g3').put(gt_2.pin['g1']) nd.Pin(name='g4').put(gt_2.pin['g2']) nd.Pin(name='g5').put(gt_3.pin['g1']) nd.Pin(name='g6').put(gt_3.pin['g2']) if self.show_pins : nd.put_stub() return ic """ Renamed for simplification in 2023.04.02 """ class GC_STD_2D: def __init__(self, name=None, etch_type :str = 'FETCH', xs_wg:str='grating', Dx_hole:float=0.3, Dy_hole:float=0.3, hole_shape :str= 'circle', shape:str = 'circle', xs_open:str = None, Px:float=0.57, Py:float=0.57, num_x:float=25, num_y:float=25, Lx_taper:float = 50, Ly_taper:float = 0, Lx_end:float = 1, Ly_end:float = 1, Lx_side:float = 0.5, Ly_side:float = 0.5, Lx_port:float=5, Ly_port:float=5, w_wg:float=0.5, show_pins:bool=False, P_AR: float = 0.6, L_AR: float = 1, ): """_summary_ Args: etch_type (str, optional): Three etch depth for election , full-etch = "FETCH", middle etch = "METCH", shallow etch = "ETCH". Defaults to 'FETCH'. xs_wg (str, optional): xsection of the grating and also the output waveguide. Defaults to 'grating'. Dx_hole (float, optional): size X of the hole, when in 'circle' hole selection ,this is the Diameter of your hole . Defaults to 0.3. Dy_hole (float, optional): size Y of the hole, when in 'circle' hole selection ,this is the Diameter of your hole . Defaults to 0.3. hole_shape (str, 'circle' | 'rectangel'): shape of the hole. Defaults to 'circle'. shape (str, 'circle' | 'rectangel'): shape of the grating. Defaults to 'circle'. Px (float, optional): Period distance X. Defaults to 0.57. Py (float, optional): Period distance Y. Defaults to 0.57. num_x (int, optional): number of pitches. Defaults to 25. num_y (int, optional): number of pitches. Defaults to 25. Lx_taper (int, optional): taper connection to the port. Defaults to 50. Ly_taper (int, optional): taper connection to the port. Defaults to 0. Lx_end (int, optional): length arratched to the end. Defaults to 5. Ly_end (int, optional): length arratched to the end. Defaults to 3. Lx_side (float, optional): side expansion. Defaults to 0.5. Ly_side (float, optional): side expansion. Defaults to 0.5. Lx_port (int, optional): output port length expansion. Defaults to 5. Ly_port (int, optional): output port length expansion. Defaults to 5. w_wg (float, optional): output port width. Defaults to 0.5. show_pins (bool, optional): _description_. Defaults to False. Raises: Exception: Period do not match D_hole """ self.name = name if (self.name==None): self.instantiate = False else : self.instantiate = True if (isinstance(Px,int) or isinstance(Px,float)) : Px = Px * np.ones(num_x) if (isinstance(Py,int) or isinstance(Py,float)) : Py = Py * np.ones(num_y) if (isinstance(Dx_hole,int) or isinstance(Dx_hole,float)) : Dx_hole = Dx_hole * np.ones((num_x)) if (isinstance(Dy_hole,int) or isinstance(Dy_hole,float)) : Dy_hole = Dy_hole * np.ones((num_y)) self.num_x = len(Px) self.num_y = len(Py) if (len(Px)!=len(Dx_hole) or len(Py)!=len(Dy_hole)): raise Exception("In Grating define : [Period] length not matching [D_hole] length") self.Lx_taper = Lx_taper self.Ly_taper = Ly_taper self.Lx_end = Lx_end self.Ly_end = Ly_end self.Lx_side = Lx_side self.Ly_side = Ly_side self.Lx_port = Lx_port self.Ly_port = Ly_port self.xs_open = xs_open self.w_wg = w_wg self.xs_wg = xs_wg self.etch_type = etch_type self.shape = shape self.hole_shape = hole_shape self.Dx_hole = Dx_hole self.Dy_hole = Dy_hole self.Px = Px self.Py = Py self.P_AR = P_AR self.L_AR = L_AR self.show_pins = show_pins if (nd.get_layer(layer="STRIP_TRE") == "STRIP_TRE"): self.positive = False if (hole_shape=='circle'): if (etch_type=="FETCH"): layer_etch = "STRIP_HOL" elif (etch_type=="METCH"): layer_etch = "RIB_HOL" elif (etch_type=="SETCH"): layer_etch = "SRIB_HOL" elif (hole_shape=='rectangle'): if (etch_type=="FETCH"): layer_etch = "STRIP_TRE" elif (etch_type=="METCH"): layer_etch = "RIB_TRE" elif (etch_type=="SETCH"): layer_etch = "SRIB_TRE" else : self.positive = True if (etch_type=="FETCH"): layer_etch = None elif (etch_type=="METCH"): layer_etch = "RIB_COR" elif (etch_type=="SETCH"): layer_etch = "SRIB_COR" self.layer_etch = layer_etch if (layer_etch!=None): if (nd.get_layer(layer_etch)!=layer_etch): layer_etch=None print("WARNING: In mxpic::passive::GC_STD_1D, ::",layer_etch," not defined in tapeout") if (self.positive): self.cell = self.generate_positive() else: self.cell = self.generate_negative() def generate_negative(self): with nd.Cell(instantiate=self.instantiate,name=self.name) as C: ## arc shape grating if (self.shape=='circle' or self.shape=='arc'): print("Sorry, this function has not been built up") ## retangular grating elif (self.shape=='rectangle'): Lx = sum(self.Px)+self.Lx_side*2 # if (self.Ly_taper==0): Ly = sum(self.Py)+self.Ly_side*2 # else: # Ly = sum(self.Py) y_offset = sum(self.Py)/2 x_offset = sum(self.Px)/2 nd.strt(length=Lx,width=Ly,xs=self.xs_wg).put(-Lx/2,0,0) if (self.xs_open!=None): circle(radius=max([Lx,Ly])*2/2,width=max([Lx,Ly])*2,xs=self.xs_open, # n_points=32 ).cell.put(0,0,0) for _x_ in range(0,self.num_x): for _y_ in range(0,self.num_y): pos_x = np.sum(self.Px[0:_x_+1])-self.Px[0]/2-x_offset pos_y = np.sum(self.Py[0:_y_+1])-y_offset-self.Py[0]/2 if (self.hole_shape=='circle'): circle(radius=self.Dx_hole[_x_]/4,width=self.Dx_hole[_x_]/2,layer=self.layer_etch, # n_points=32, sharp_patch=False).cell.put(pos_x,pos_y,0) elif (self.hole_shape=='rectangle'): nd.strt(length=self.Dx_hole[_x_],width=self.Dy_hole[_y_],layer=self.layer_etch).put(pos_x-self.Dx_hole[_x_]/2,pos_y,0) else : raise Exception("ERROR: In , is not defined, please input [circle | rectangle]") if (self.Ly_taper!=0): nd.strt(length=self.Ly_end,width=Lx,xs=self.xs_wg).put(0,Ly/2,90) if (self.P_AR>0): _num_AR_ = int(np.floor(self.L_AR/self.P_AR)+1) for _idx_ in range(0,_num_AR_): # nd.strt(xs=self.xs_wg,width=Lx,length=self.P_AR/2).put(0,self.P_AR/2+Ly/2+self.Ly_end+self.P_AR*_idx_,90) nd.strt(xs=self.xs_wg,width=self.P_AR/2,length=Lx).put(-Lx/2,self.P_AR+Ly/2+self.Ly_end+self.P_AR*_idx_,0) # if (self.P_AR >0 and self.L_AR>0): # _num_AR_ = int(np.floor(Ly/self.P_AR)) # for _idx_ in range(0,_num_AR_): # nd.taper(xs=self.xs_wg,width1=self.P_AR-0.2,width2=0.2,length=self.L_AR).put(_idx_*self.P_AR - (_num_AR_-1)/2*self.P_AR+Lx/2,Ly/2+self.Ly_end,90) nd.strt(length=self.Ly_end,width=Lx,xs=self.xs_wg).put(0,-Ly/2,-90) y_port = nd.taper(width1=Ly,width2=self.w_wg,xs=self.xs_wg,length=self.Ly_taper).put() y_port = nd.strt(length=self.Ly_port,width=self.w_wg,xs=self.xs_wg).put() nd.Pin(name='g2',pin=y_port.pin['b0']).put() nd.strt(length=self.Lx_end,width=Ly,xs=self.xs_wg).put(Lx/2,0,0) ## adding anti reflection if (self.Lx_taper!=0): if (self.P_AR>0): _num_AR_ = int(np.floor(self.L_AR/self.P_AR)+1) for _idx_ in range(0,_num_AR_): # nd.strt(xs=self.xs_wg,width=Lx,length=self.P_AR/2).put(self.P_AR/2+Lx/2+self.Lx_end+self.P_AR*_idx_,0,0) nd.strt(xs=self.xs_wg,length=Ly,width=self.P_AR/2).put(self.P_AR+Lx/2+self.Lx_end+self.P_AR*_idx_,-Ly/2,90) # _num_AR_ = int(np.floor(Ly/self.P_AR)) # for _idx_ in range(0,_num_AR_): # nd.taper(xs=self.xs_wg,width1=self.P_AR-0.2,width2=0.2,length=self.L_AR).put(Lx+self.Lx_end,_idx_*self.P_AR - (_num_AR_-1)/2*self.P_AR,0) nd.strt(length=self.Lx_end,width=Ly,xs=self.xs_wg).put(-Lx/2,0,180) x_port = nd.taper(width1=Ly,width2=self.w_wg,xs=self.xs_wg,length=self.Lx_taper).put() x_port = nd.strt(length=self.Lx_port,width=self.w_wg,xs=self.xs_wg).put() nd.Pin(name='g1',pin=x_port.pin['b0']).put() # print("Sorry, this function has not been built up") else : raise Exception("In Grating define : [shape] not defined") if (self.show_pins): nd.put_stub(pinsize=3) return C def generate_positive(self): with nd.Cell(instantiate=self.instantiate,name=self.name) as C: ## arc shape grating if (self.shape=='circle' or self.shape=='arc'): print("Sorry, this function has not been built up") pass ## retangular grating elif (self.shape=='rectangle'): Lx = sum(self.Px) if (self.Ly_taper==0): Ly = sum(self.Py)+self.Ly_side*2 nd.strt(length=Lx,width=self.Ly_side,xs=self.xs_wg).put(0,sum(self.Py)/2+self.Lx_side/2,0) nd.strt(length=Lx,width=self.Ly_side,xs=self.xs_wg).put(0,-sum(self.Py)/2-self.Lx_side/2,0) else: Ly = sum(self.Py) y_offset = sum(self.Py)/2 if (self.layer_etch!=None): nd.strt(length=Lx,width=Ly,layer=self.layer_etch).put(0,0,0) if (self.xs_open!=None): nd.strt(length=Lx*2,width=Ly*2,xs=self.xs_open).put(-Lx/2,0,0) for _x_ in range(0,self.num_x): for _y_ in range(0,self.num_y): pos_x = np.sum(self.Px[0:_x_+1])-self.Px[0]/2 pos_y = np.sum(self.Py[0:_y_+1])-y_offset-self.Py[0]/2 hole(r_hole=self.Dx_hole[_x_]/2,Lx_sq=self.Px[_x_],Ly_sq=self.Py[_y_], Dx_hole=self.Dx_hole[_x_],Dy_hole=self.Dy_hole[_y_], # n_points=12, xs=self.xs_wg,hole_shape=self.hole_shape).cell.put(pos_x,pos_y,0) if (self.Ly_taper!=0): nd.strt(length=self.Ly_end,width=Lx,xs=self.xs_wg).put(Lx/2,Ly/2,90) _num_AR_ = int(np.floor(Ly/self.P_AR)) for _idx_ in range(0,_num_AR_): nd.taper(xs=self.xs_wg,width1=self.P_AR-0.2,width2=0.2,length=self.L_AR).put(_idx_*self.P_AR - (_num_AR_-1)/2*self.P_AR+Lx/2,Ly/2+self.Ly_end,90) nd.strt(length=self.Ly_end,width=Lx,xs=self.xs_wg).put(Lx/2,-Ly/2,-90) y_port = nd.taper(width1=Ly,width2=self.w_wg,xs=self.xs_wg,length=self.Lx_taper).put() y_port = nd.strt(length=self.Ly_port,width=self.w_wg,xs=self.xs_wg).put() nd.Pin(name='g2',pin=y_port.pin['b0']).put() nd.strt(length=self.Lx_end,width=Ly,xs=self.xs_wg).put(Lx,0,0) ## adding anti reflection _num_AR_ = int(np.floor(Ly/self.P_AR)) for _idx_ in range(0,_num_AR_): nd.taper(xs=self.xs_wg,width1=self.P_AR-0.2,width2=0.2,length=self.L_AR).put(Lx+self.Lx_end,_idx_*self.P_AR - (_num_AR_-1)/2*self.P_AR,0) nd.strt(length=self.Lx_end,width=Ly,xs=self.xs_wg).put(0,0,180) x_port = nd.taper(width1=Ly,width2=self.w_wg,xs=self.xs_wg).put() x_port = nd.strt(length=self.Lx_port,width=self.w_wg,xs=self.xs_wg).put() nd.Pin(name='g1',pin=x_port.pin['b0']).put() else : raise Exception("In Grating define : [shape] not defined") if (self.show_pins): nd.put_stub(pinsize=3) return C def generate_test_gds(self,dX_gc2gc=300): with nd.Cell(instantiate=False) as C: self.cell.put('g1',-dX_gc2gc/2,0,180) self.cell.put('g1', dX_gc2gc/2,0,0) nd.strt(xs=self.xs_wg,width=self.w_wg,length=dX_gc2gc).put(-dX_gc2gc/2,0,0) return C class GC_STD_1D: def __init__ (self, name=None, xs_wg : str = 'strip', w_wg : float = 0.5, etch_type :str = 'FETCH', xs_open :str=None, L_taper :float = 10, L_end :float = 2, A_taper :float = 30, Period :float = 0.5, eta_etch :float = 0.5, num :float = 20, ### note, when Period and eta is defined as list, this is not usefull sector_gc :bool =True, show_pins=False, L_tail = 2, # n_points = 64, P_AR: float = 1, ### adding anti reflection pitches L_AR: float = 2, ): self.name = name if (self.name==None): self.instantiate = False else : self.instantiate = True if (xs_open!=None): try: nd.get_xsection(xs_open) except: xs_open=None print("WARNING:In , ::",xs_open," not defined in tapeout") self.xs_open=xs_open self.xs_wg=xs_wg self.w_wg=w_wg self.L_taper=L_taper self.L_end=L_end self.A_taper=A_taper self.show_pins = show_pins self.L_tail = L_tail if (isinstance(eta_etch,list) or isinstance(eta_etch,np.ndarray)): num = len(eta_etch) if (isinstance(Period,list) or isinstance(Period,np.ndarray)): num = len(Period) if (isinstance(Period,int) or isinstance(Period,float)): Period = Period*np.ones(num) if (isinstance(eta_etch,int) or isinstance(eta_etch,float)): eta_etch = eta_etch*np.ones(num) """ Generate ERROR """ if (len(Period)!=len(eta_etch)): raise Exception("ERROR: In : [Period] length not matching [eta_etch] length") if (nd.get_layer(layer="STRIP_TRE") == "STRIP_TRE"): self.positive = False if (etch_type=="FETCH"): layer_etch = "STRIP_TRE" elif (etch_type=="METCH"): layer_etch = "RIB_TRE" elif (etch_type=="SETCH"): layer_etch = "SRIB_TRE" else : self.positive = True if (etch_type=="FETCH"): layer_etch = None elif (etch_type=="METCH"): layer_etch = "RIB_COR" elif (etch_type=="SETCH"): layer_etch = ["SRIB_COR","RIB_COR"] self.Period=Period self.eta_etch=eta_etch self.num=len(Period) self.sector_gc=sector_gc # self.n_points = n_points ## revise 2022.08.18 self.L_AR = L_AR self.P_AR = P_AR if (layer_etch!=None): if (isinstance(layer_etch,str)): if (nd.get_layer(layer_etch)!=layer_etch): layer_etch=None print("WARNING: In mxpic::passive::GC_STD_1D, ::",layer_etch," not defined in tapeout") else : for _layer_ in layer_etch: if (nd.get_layer(_layer_)!=_layer_): layer_etch=None print("WARNING: In mxpic::passive::GC_STD_1D, ::",layer_etch," not defined in tapeout") self.layer_etch = layer_etch if (self.positive): self.cell = self.generate_positive() else: self.cell = self.generate_negative() def generate_negative(self): with nd.Cell(instantiate=self.instantiate,name=self.name) as C: ## arc shape grating if (self.sector_gc == True): L_total = np.sum(self.Period) + self.L_taper + self.L_end L_tail = self.L_tail for layers,growx,growy,acc in nd.layeriter(xs=self.xs_wg): (a1,b1), (a2,b2),c1,c2 = growx x_offset = -b1/np.sin(self.A_taper/2*np.pi/180) if (self.P_AR>0 and self.L_AR>0): ## anti reflection r_tap = L_total*1.3 - b1 - x_offset else : r_tap = L_total + b1 - x_offset circle(radius=r_tap/2,width=r_tap, theta_start=-self.A_taper/2,theta_stop=self.A_taper/2, # n_points=self.n_points, layer=layers).cell.put(x_offset,0,0) _L_tail_ = np.abs(x_offset) if _L_tail_ > L_tail: L_tail = _L_tail_ r_grat_inner = self.L_taper for _idx_ in range(0,self.num): d_pitch = self.Period[_idx_]*self.eta_etch[_idx_] circle(radius=r_grat_inner + d_pitch/2, width=d_pitch, theta_start=-self.A_taper/2-5,theta_stop=self.A_taper/2+5, # n_points=self.n_points, layer=self.layer_etch).cell.put(0,0,0) r_grat_inner = r_grat_inner + self.Period[_idx_] L_open = 1.5*(L_total-self.L_taper) W_open = 1.1*(L_total*np.tan(self.A_taper/2*np.pi/180))*2 x_open = (L_total+self.L_taper)/2 - L_open/2 if (self.xs_open!=None): nd.strt(length=L_open,width=W_open,xs=self.xs_open).put(x_open,0,0) nd.strt(length=L_tail,width=self.w_wg,xs=self.xs_wg).put(-L_tail,0,0) nd.Pin(name='g1',width=self.w_wg).put(-L_tail,0,180) nd.strt(length=np.abs(self.w_wg/2/np.tan(self.A_taper/2/180*np.pi)),width=self.w_wg,xs=self.xs_wg).put(0,0,0) ## retangular grating else: L_total = np.sum(self.Period) + self.L_taper + self.L_end L_grat = sum(self.Period)+self.L_end W_grat = self.w_wg + self.L_taper*np.tan(self.A_taper/2*np.pi/180)*2 nd.taper(length=self.L_taper,width1=self.w_wg,width2=W_grat,xs=self.xs_wg).put(0,0,0) nd.strt(length=L_grat,width=W_grat,xs=self.xs_wg).put(self.L_taper,0,0) ### adding Anti-reflection # if (self.P_AR>0 and self.L_AR>0): # _num_AR_ = int(np.floor(W_grat/self.P_AR)) # for _idx_ in range(0,_num_AR_): # nd.taper(xs=self.xs_wg,width1=self.P_AR-0.2,width2=0.2,length=self.L_AR).put(self.L_taper+L_grat, (_idx_ - (_num_AR_-1)/2)*self.P_AR,0) x_grat = self.L_taper for _idx_ in range(0,self.num): nd.strt(length=self.Period[_idx_]*self.eta_etch[_idx_],width=W_grat+2,layer=self.layer_etch).put(x_grat,0,0) x_grat = x_grat + self.Period[_idx_] nd.strt(length=10,width=self.w_wg,xs=self.xs_wg).put(-5,0,0) nd.Pin(name='g1',width=self.w_wg).put(-5,0,180) L_open = 1.5*(L_total-self.L_taper) W_open = 1.1*(L_total*np.tan(self.A_taper/2*np.pi/180))*2 x_open = (L_total+self.L_taper)/2 - L_open/2 if (self.xs_open!=None): nd.strt(length=L_open,width=W_open,xs=self.xs_open).put(x_open,0,0) pass if (self.show_pins): nd.put_stub() return C def generate_positive(self): with nd.Cell(instantiate=False) as C: ## arc shape grating if (self.sector_gc==True): L_tail = self.L_tail for layers,growx,growy,acc in nd.layeriter(xs=self.xs_wg): (a1,b1), (a2,b2),c1,c2 = growx x_offset = -b1/np.sin(self.A_taper/2*np.pi/180) r_tap = self.L_taper + b1 - x_offset circle(radius=r_tap/2,width=r_tap, theta_start=-self.A_taper/2,theta_stop=self.A_taper/2, # n_points=self.n_points, layer=layers).cell.put(x_offset,0,0) r_grat_inner = self.L_taper - x_offset _L_tail_ = np.abs(x_offset) if _L_tail_ > L_tail: L_tail = _L_tail_ for _idx_ in range(0,self.num): d_pitch = self.Period[_idx_]*(1-self.eta_etch[_idx_])+b1*2 circle(radius=r_grat_inner + self.Period[_idx_]*self.eta_etch[_idx_] + d_pitch/2, width=d_pitch, theta_start=-self.A_taper/2,theta_stop=self.A_taper/2, # n_points=self.n_points, layer=layers).cell.put(x_offset,0,0) r_grat_inner = r_grat_inner + self.Period[_idx_] d_pitch = self.L_end+b1*2 r_grat_inner = r_grat_inner + self.Period[-1]*self.eta_etch[-1] circle(radius=r_grat_inner + d_pitch/2, width=d_pitch, theta_start=-self.A_taper/2,theta_stop=self.A_taper/2, # n_points=64, layer=layers).cell.put(x_offset,0,0) nd.strt(length=L_tail*2,width=self.w_wg,xs=self.xs_wg).put(-L_tail,0,0) nd.Pin(name='g1',width=self.w_wg).put(-L_tail,0,180) L_total = np.sum(self.Period) + self.L_taper + self.L_end L_open = 1.5*(L_total-self.L_taper) W_open = 1.2*(L_total*np.tan(self.A_taper/2*np.pi/180))*2 x_open = (L_total+self.L_taper)/2 - L_open/2 if (self.layer_etch!=None): if (isinstance(self.layer_etch,str)): nd.strt(length=L_open,width=W_open,layer=self.layer_etch).put(x_open,0,0) elif(isinstance(self.layer_etch,list)): for _layer_ in self.layer_etch: nd.strt(length=L_open,width=W_open,layer=_layer_).put(x_open,0,0) if (self.xs_open!=None): nd.strt(length=L_open,width=W_open,xs=self.xs_open).put(x_open,0,0) ## retangular grating elif (self.shape=='rectangle'): L_grat = sum(self.Period) W_grat = self.w_wg + self.L_taper*np.tan(self.A_taper/2*np.pi/180)*2 nd.taper(length=self.L_taper,width1=self.w_wg,width2=W_grat,xs=self.xs_wg).put(0,0,0) x_grat = self.L_taper for _idx_ in range(0,self.num): nd.strt(length=self.Period[_idx_]*(1-self.eta_etch[_idx_]),width=W_grat,xs=self.xs_wg).put(x_grat+self.Period[_idx_]*self.eta_etch[_idx_],0,0) x_grat = x_grat + self.Period[_idx_] nd.strt(length=10,width=self.w_wg,xs=self.xs_wg).put(-5,0,0) nd.Pin(name='g1',width=self.w_wg).put(-5,0,180) ### adding Anti-reflection if (self.P_AR>0 and self.L_AR>0): _num_AR_ = int(np.floor(W_grat/self.P_AR)) for _idx_ in range(0,_num_AR_): nd.taper(xs=self.xs_wg,width1=self.P_AR-0.2,width2=0.2,length=self.L_AR).put(self.L_taper+L_grat, (_idx_ - (_num_AR_-1)/2)*self.P_AR,0) L_total = np.sum(self.Period) + self.L_taper + self.L_end L_open = 1.5*(L_total-self.L_taper) W_open = 1.1*(L_total*np.tan(self.A_taper/2*np.pi/180))*2 x_open = (L_total+self.L_taper)/2 - L_open/2 if (self.layer_etch!=None): nd.strt(length=L_open,width=W_open,layer=self.layer_etch).put(x_open,0,0) if (self.xs_open!=None): nd.strt(length=L_open,width=W_open,xs=self.xs_open).put(x_open,0,0) pass else : raise Exception("In Grating define : [shape] not defined") if (self.show_pins): nd.put_stub() return C def generate_test_dev(self,dX_gc2gc): with nd.Cell(instantiate=False) as C: self.cell.put('g1',-dX_gc2gc/2,0,180) self.cell.put('g1', dX_gc2gc/2,0,0) nd.strt(xs=self.xs_wg,width=self.w_wg,length=dX_gc2gc).put(-dX_gc2gc/2,0,0) return C class FA: def __init__(self,fiber_coupler,pitch,number,show_pins=False): # if (isinstance(fiber_coupler,nd.Cell)): # fiber_cell = fiber_coupler # elif (hasattr(fiber_coupler,'cell')): # fiber_cell = fiber_coupler.cell # else: # raise Exception("ERROR: In , not recongized, please input nazca.cell or classes that has nazca.cell") fiber_cell = __cell_arg__(arg=fiber_coupler,arg_name="fiber_coupler",func_name="mxpic::FA") pin_in_name = [] for name,Pin in fiber_cell.ic_pins(): pin_in_name = pin_in_name+[name] # pin_in_name.append(name) if ('g1' in pin_in_name): pin_name = 'g1' else: pin_name = 'a0' print("WARNING: In , dose not contain 'g1' pin, using 'a0' in default") self.pitch = pitch self.number = number with nd.Cell(instantiate=False) as C: for idx in range(1,number+1): port = fiber_cell.put(pin_name,0,pitch*(idx-number/2-1/2),0) nd.Pin('g'+str(idx),pin=port.pin[pin_name]).put() x_out = port.pin['b0'].x nd.Pin(name='b0').put(x_out,0,180) if (show_pins): nd.put_stub(pinsize=3) self.cell = C