class AlignmentMarkerSet(i3.PCell): _name_prefix = "ALIGNMENT MARKER SET" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Spacing v_spacing = i3.PositiveNumberProperty(default=5000.0) class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position # ADD RELEASE elems += i3.SRef(reference=Interface(pocket=False, tilt=False), transformation=i3.Translation( (x0, 0.0 * self.v_spacing + y0))) elems += i3.SRef(reference=Interface(pocket=True, tilt=False), transformation=i3.Translation( (x0, 1.0 * self.v_spacing + y0))) elems += i3.SRef(reference=Interface(pocket=False, tilt=True), transformation=i3.Translation( (x0, 2.0 * self.v_spacing + y0))) elems += i3.SRef(reference=Interface(pocket=True, tilt=True), transformation=i3.Translation( (x0, 3.0 * self.v_spacing + y0))) return elems
class Layout(i3.LayoutView): channel_template = microfluidics.ShortChannelTemplate() #inlet_diameter = i3.NumberProperty(default =300.) cInp = i3.Coord2Property(default=(0.0, 0.0)) def _generate_elements(self, elems): #solid #circle = i3.ShapeCircle(center=(0.0,0.0), radius=self.inlet_diameter*0.5) #elems += i3.Boundary(layer=i3.TECH.PPLAYER.CH2.TRENCH, shape=circle) #line (faster on MLA) elems += i3.CirclePath(layer=i3.TECH.PPLAYER.CH1.TRENCH, center=(26e3, 9e3), radius=self.diameter * 0.5, line_width=200) elems += i3.CirclePath(layer=i3.TECH.PPLAYER.CH1.TRENCH, center=(-26e3, 9e3), radius=self.diameter * 0.5, line_width=200) elems += i3.CirclePath(layer=i3.TECH.PPLAYER.CH1.TRENCH, center=(-26e3, -9e3), radius=self.diameter * 0.5, line_width=200) elems += i3.CirclePath(layer=i3.TECH.PPLAYER.CH1.TRENCH, center=(26e3, -9e3), radius=self.diameter * 0.5, line_width=200) return elems
class Layout(i3.LayoutView): channel_template = microfluidics.ShortChannelTemplate() #inlet_diameter = i3.NumberProperty(default =300.) cInp = i3.Coord2Property(default=(0.0, 0.0)) def _generate_elements(self, elems): #solid #circle = i3.ShapeCircle(center=(0.0,0.0), radius=self.inlet_diameter*0.5) #elems += i3.Boundary(layer=i3.TECH.PPLAYER.CH2.TRENCH, shape=circle) #line (faster on MLA) elems += i3.CirclePath(layer=i3.TECH.PPLAYER.CH2.TRENCH, center=(0.0, 0.0), radius=self.diameter * 0.5, line_width=200) return elems def _generate_ports(self, ports): ports += microfluidics.FluidicPort( name='in', position=(0.0, 0.0), direction=i3.PORT_DIRECTION.IN, trace_template=self.channel_template, angle_deg=90) ports += microfluidics.FluidicPort( name='out', position=(0.0, 0.0), direction=i3.PORT_DIRECTION.OUT, trace_template=self.channel_template, angle_deg=90) return ports
class PI(i3.PCell): _name_prefix = "PI" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Layer layer = i3.LayerProperty(default=i3.TECH.PPLAYER.HFW) layer_bool = i3.LayerProperty(default=i3.TECH.PPLAYER.NONE.DOC) # Mesa parameters length = i3.PositiveNumberProperty(default=7000.0) width = i3.PositiveNumberProperty(default=630.0) pocket = i3.BoolProperty(default=False) tilt = i3.BoolProperty(default=False) # Recess label label = i3.StringProperty(default="PI_") class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position elems += i3.Rectangle(layer=self.layer, center=(x0 + 6500, y0 + 1000 + (3000 - self.width) / 4), box_size=(self.length, (3000 - self.width) / 2)) elems += i3.Rectangle(layer=self.layer, center=(x0 + 6500, y0 + 1000 + self.width + (3000 - self.width) * 3 / 4), box_size=(self.length, (3000 - self.width) / 2)) elems += i3.SRef(reference=Interface(pocket=self.pocket, tilt=self.tilt)) for i in range(7): elems += i3.Rectangle(layer=self.layer, center=(10000 - 725 - i * 750, 1000 + (3000 - self.width) / 2 + 185), box_size=(50, 50)) elems += i3.Rectangle(layer=self.layer, center=(10000 - 725 - i * 750, 1000 + (3000 - self.width) / 2 + self.width - 185), box_size=(50, 50)) if self.pocket: self.label += "WP" if self.tilt: self.label += "WT" elems += i3.PolygonText(layer=self.layer_bool, text=self.label, coordinate=(6000, 4000), # alignment=(i3.TEXT_ALIGN_LEFT, i3.TEXT_ALIGN_LEFT), font=2, height=700.0) generated1 = self.layer - self.layer_bool mapping = {generated1: self.layer} elems = i3.get_elements_for_generated_layers(elems, mapping) return elems
class Interface_mmi12(i3.PCell): _name_prefix = "INTERFACE_" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Layer layer = i3.LayerProperty(default=i3.TECH.PPLAYER.HFW) layer_bool = i3.LayerProperty(default=i3.TECH.PPLAYER.NONE.DOC) # Mesa parameters length = i3.PositiveNumberProperty(default=2500) # shrink width = i3.PositiveNumberProperty(default=3000.0 * 0.6) pocket = i3.BoolProperty(default=False) tilt = i3.BoolProperty(default=False) class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position elems += i3.Rectangle(layer=self.layer, center=(x0 + 7500 + 2000+1500, y0 + 4500 - 1800+500), box_size=(10000, 1600)) # change # elems += i3.Rectangle(layer=i3.TECH.PPLAYER.NONE.DOC, center=(x0 + 7500, y0 + 4500), # box_size=(15000, 1000)) elems += i3.Rectangle(layer=self.layer, center=(x0 + 7500 + 2000+1500, y0 + 500 - 200-500), box_size=(10000, 1600)) elems += i3.Rectangle(layer=self.layer, center=(x0 + 12500 + 1000 - 250, y0 + 2500 - 1000), # change box_size=(self.length, self.width)) elems +=i3.Rectangle(layer=self.layer, center=(x0+ 15250, y0+1500),box_size=(1500,1800)) #add if self.pocket: PO = i3.Rectangle(layer=self.layer_bool, center=(10001 + 2000, 2500 - 1000), box_size=(2, 160)) # change elems += PO generated1 = self.layer - self.layer_bool mapping = {generated1: self.layer} elems = i3.get_elements_for_generated_layers(elems, mapping) if self.tilt: # TI = i3.Rectangle(layer=self.layer_bool, center=(10001, 2500), box_size=(2, 160)) # elems += TI TI_shape = i3.Shape(points=[(10000.0 + 2000, 2470.0 - 1000), (10010.58 + 2000, 2530.0 - 1000), (10000.0 + 2000, 2530.0 - 1000)], closed=True) # change TI = i3.Boundary(layer=self.layer_bool, shape=TI_shape) elems += TI generated1 = self.layer - self.layer_bool mapping = {generated1: self.layer} elems = i3.get_elements_for_generated_layers(elems, mapping) return elems
class dicingMarker(i3.PCell): _name_prefix = "markers" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Layer layer = i3.LayerProperty(default=i3.TECH.PPLAYER.HFW) # layer_bool = i3.LayerProperty(default=i3.TECH.PPLAYER.NONE.DOC) class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position for i in range(0, 4, 1): for j in range(0, 3, 1): elems += i3.Rectangle(layer=self.layer, center=(x0 + i * 6000, y0 + j * 7000), box_size=(100, 100)) elems += i3.Rectangle(layer=self.layer, center=(x0 + 200 + i * 6000, y0 + j * 7000), box_size=(100, 100)) elems += i3.Rectangle(layer=self.layer, center=(x0 + i * 6000, y0 + 200 + j * 7000), box_size=(100, 100)) elems += i3.Rectangle(layer=self.layer, center=(x0 + i * 6000 + 200, y0 + 200 + j * 7000), box_size=(100, 100)) for k in range(0, 20, 1): elems += i3.Rectangle( layer=self.layer, center=(-1000 + 0 + i * 6000, 1000 + 10 * k + j * 7000), box_size=(500, 0.6 + 0.2 * k)) elems += i3.PolygonText( layer=self.layer, text="{}".format(str(k)), # coordinate=(1300.0, 100.0), # alignment=(i3.TEXT_ALIGN_LEFT, i3.TEXT_ALIGN_LEFT), font=2, height=7.0, transformation=i3.Translation( (-1000 + 260 + i * 6000, 1000 + 3 + 10 * k + j * 7000))) elems += i3.Rectangle(layer=i3.TECH.PPLAYER.NONE.DOC, center=(9000, 7500), box_size=(21000, 16000)) # elems += i3.Rectangle(layer=i3.TECH.PPLAYER.CONTACT.PILLAR, center=(8500, 7500), # box_size=(22000, 18000)) return elems
class Layout(i3.LayoutView): channel_template = microfluidics.ShortChannelTemplate() cInp = i3.Coord2Property(default=(0.0, 0.0)) def _generate_elements(self, elems): elems += i3.PolygonText(layer=i3.TECH.PPLAYER.CH2.TRENCH, coordinate=(0., 0.), text=self.text, height=self.font_size) return elems
class SiN_NP(i3.PCell): _name_prefix = "SiN_NP" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Layer layer = i3.LayerProperty(default=i3.TECH.PPLAYER.SIL.LINE) layer_bool = i3.LayerProperty(default=i3.TECH.PPLAYER.NONE.DOC) # Mesa parameters length = i3.PositiveNumberProperty(default=7000.0) width = i3.PositiveNumberProperty(default=330.0) pillar = i3.BoolProperty(default=False) tilt_0 = i3.BoolProperty(default=False) class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position elems += i3.Rectangle(layer=self.layer, center=(1500 - 20, 2500), box_size=(3000 - 40, 3000 - 40 * 2)) if self.tilt_0: elems += i3.Rectangle(layer=self.layer, center=(x0 + 6500 - 40 + 20 + 7.5, 2500), box_size=(self.length + 40 + 15, self.width - 40 * 2)) else: elems += i3.Rectangle(layer=self.layer, center=(x0 + 6500 - 40 + 20 + 5, 2500), box_size=(self.length + 40 + 10, self.width - 40 * 2)) if self.pillar: for i in range(7): elems += i3.Rectangle( layer=self.layer_bool, center=(10000 - 725 - i * 750, 1000 + (3000 - self.width) / 2 + 30), box_size=(130, 140)) elems += i3.Rectangle( layer=self.layer_bool, center=(10000 - 725 - i * 750, 1000 + (3000 - self.width) / 2 + self.width - 30), box_size=(130, 140)) generated1 = self.layer - self.layer_bool mapping = {generated1: self.layer} elems = i3.get_elements_for_generated_layers(elems, mapping) return elems
class Layout(i3.LayoutView): channel_template = microfluidics.ShortChannelTemplate() size = i3.NumberProperty(default=10e4) cInp = i3.Coord2Property(default=(0.0, 0.0)) def _generate_elements(self, elems): elems += i3.CirclePath(layer=i3.TECH.PPLAYER.CH2.TRENCH, center=(0.0, 0.0), radius=self.size * 0.5, line_width=200) return elems
class Release(i3.PCell): _name_prefix = "RELEASE" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Layer lay_release = i3.Layer(number=4, name="release") layer = i3.LayerProperty(default=lay_release) # Mesa parameters length = i3.PositiveNumberProperty(default=800.0) width = i3.PositiveNumberProperty(default=40.0) release_margin = i3.PositiveNumberProperty(default=12.5) release_tether_period = i3.PositiveNumberProperty(default=45.0) release_tether_length = i3.PositiveNumberProperty(default=17.5) release_tether_width = i3.PositiveNumberProperty(default=8.0) class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position # elems += i3.Rectangle(layer=self.layer, center=(x0, y0), # box_size=(self.length + self.release_margin, self.width + self.release_margin)) elems += i3.Rectangle(layer=self.layer, center=(300, 300), box_size=(200, 200)) rec = i3.Rectangle(layer=self.layer, center=(0, 0), box_size=(200, 200)) layer2 = i3.Layer(2) remove = i3.Wedge(layer=layer2, begin_coord=(-100, 0), end_coord=(-50, 0), begin_width=8, end_width=0.001) elems += rec elems += remove generated1 = self.layer - layer2 mapping = {generated1: self.layer} output_elems = i3.get_elements_for_generated_layers(elems, mapping) # # elems = elems | wedge, # haha = rec | remove, # elems += remove, # # elems +=rec, # elems = elems.extend(haha), return output_elems
class JoinedObstacles(i3.PCell): #(Structure): channel_template = microfluidics.ChannelTemplateProperty( default=microfluidics.ShortChannelTemplate(), doc="Channel template for ports") mysingleObstacle = i3.ChildCellProperty( doc='the single Obstacle child cell, which will be clonned many times', default=Obstacle_BooleanBoundary()) wholeTrapX = i3.PositiveNumberProperty( default=500.0, doc="total X distance length of traps") wholeTrapY = i3.PositiveNumberProperty( default=500.0, doc="total Y distance length of traps") cInp = i3.Coord2Property(default=0.0, doc="") class Layout(i3.LayoutView): def _generate_instances(self, insts): x_inc = (self.mysingleObstacle.gap_btw_barriers + self.mysingleObstacle.obstacle_trap_length) * 2 y_inc = self.mysingleObstacle.channel_trap_width * 1.5 cycles_x = int(self.wholeTrapX / ((self.mysingleObstacle.gap_btw_barriers + self.mysingleObstacle.obstacle_trap_length) * 2)) cycles_y = int(self.wholeTrapY / (y_inc)) insts += i3.ARef(reference=self.mysingleObstacle, origin=(0, 0.0 * self.cell.wholeTrapY), period=(x_inc, y_inc), n_o_periods=(cycles_x, cycles_y)) print 'insts', insts return insts def _generate_ports(self, ports): #port1 ports += microfluidics.FluidicPort( name='in', position=(0, self.wholeTrapY * 0.5), #position = (0, 'insts_0'.size_info().north*0.5), direction=i3.PORT_DIRECTION.IN, angle_deg=180, trace_template=self.cell.channel_template) #port2 ports += microfluidics.FluidicPort( name='out', position=(self.wholeTrapX, self.wholeTrapY * 0.5), direction=i3.PORT_DIRECTION.OUT, angle_deg=0, trace_template=self.cell.channel_template) return ports
class Layout(i3.LayoutView): channel_template = microfluidics.ShortChannelTemplate() length = i3.NumberProperty(default=60e3) width = i3.NumberProperty(default=20e3) cInp = i3.Coord2Property(default=(0.0, 0.0)) def _generate_elements(self, elems): elems += i3.RoundedRectanglePath(layer=i3.TECH.PPLAYER.CH2.TRENCH, center=(0.0, 0.0), box_size=(self.length, self.width), radius=200., line_width=2.0) return elems
class PlaceMyComponents(i3.PCell): _name_prefix = "place" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # # Coupon parameters # length = i3.PositiveNumberProperty(default=2750.0) # width = i3.PositiveNumberProperty(default=85.0) class Layout(i3.LayoutView): def _generate_elements(self, elems): # # Center of the structure # (x0, y0) = self.position # # RELEASE c1 = Coupon(length=40) #2750 label A no need for shrink elems += i3.SRef(reference=c1, transformation=i3.Translation((0, 0))) elems += i3.SRef(reference=c1, transformation=i3.Translation((10700, 0))) elems += i3.SRef(reference=c1, transformation=i3.Translation((0, 10705))) elems += i3.SRef(reference=c1, transformation=i3.Translation((-10700, 0))) elems += i3.SRef(reference=c1, transformation=i3.Translation((-10700 * 2, 0))) elems += i3.SRef(reference=c1, transformation=i3.Translation((-10700, 10705))) elems += i3.SRef(reference=c1, transformation=i3.Translation((0, -10705))) elems += i3.SRef(reference=c1, transformation=i3.Translation((10700, -10705))) elems += i3.SRef(reference=c1, transformation=i3.Translation((-10700, -10705))) elems += i3.SRef(reference=c1, transformation=i3.Translation( (-10700 * 2, -10705))) elems += i3.SRef(reference=c1, transformation=i3.Translation((0, -10705 * 2))) elems += i3.SRef(reference=c1, transformation=i3.Translation( (-10700, -10705 * 2))) Medphab = mmi_slots_cell_test() elems += i3.SRef(reference=Medphab) return elems
class AL_PI(i3.PCell): _name_prefix = "AL_PI" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Layer layer = i3.LayerProperty(default=i3.TECH.PPLAYER.CONTACT.PILLAR) layer_bool = i3.LayerProperty(default=i3.TECH.PPLAYER.NONE.DOC) # Mesa parameters length = i3.PositiveNumberProperty(default=7000.0) width = i3.PositiveNumberProperty(default=630.0) class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position elems += i3.Rectangle(layer=self.layer, center=(1500 - 20, 2500), box_size=(3000 - 40, 3000 - 40 * 2)) elems += i3.Rectangle(layer=self.layer, center=(x0 + 6500 - 40, 2500), box_size=(self.length, self.width - 40 * 2)) for i in range(7): elems += i3.Rectangle(layer=self.layer_bool, center=(10000 - 725 - i * 750, 1000 + (3000 - self.width) / 2 + 185), box_size=(130, 130)) elems += i3.Rectangle( layer=self.layer_bool, center=(10000 - 725 - i * 750, 1000 + (3000 - self.width) / 2 + self.width - 185), box_size=(130, 130)) generated1 = self.layer - self.layer_bool mapping = {generated1: self.layer} elems = i3.get_elements_for_generated_layers(elems, mapping) return elems
class Layout(i3.LayoutView): channel_template = microfluidics.ShortChannelTemplate() cInp = i3.Coord2Property(default=(0.0, 0.0)) def _generate_elements(self, elems): elems += i3.CirclePath(layer=i3.TECH.PPLAYER.CH2.TRENCH, center=(0.0, 0.0), radius=self.diameter * 0.5, line_width=50) point_list = [] point_list.append((0, -self.diameter * 0.5)) point_list.insert(0, (0, self.diameter * 0.5)) point_list.append( (self.diameter * self.cell.reduction_ratio, -self.diameter * 0.5 * self.cell.reduction_ratio)) point_list.insert( 0, (self.diameter * self.cell.reduction_ratio, self.diameter * 0.5 * self.cell.reduction_ratio)) funnel = i3.Shape(point_list, closed=True) bo = i3.Boundary(i3.TECH.PPLAYER.CH2.TRENCH, funnel) elems += bo return elems def _generate_ports(self, ports): '''ports += microfluidics.FluidicPort(name='in', position=(0.0, 0.0), direction=i3.PORT_DIRECTION.IN, trace_template=self.channel_template, angle_deg=0 )''' ports += microfluidics.FluidicPort( name='out', position=(self.diameter * self.cell.reduction_ratio, 0.0), direction=i3.PORT_DIRECTION.OUT, trace_template=self.channel_template, angle_deg=180) return ports
class ImportRik(i3.PCell): _name_prefix = "ImportRik" # Center of the structure position = i3.Coord2Property(default=(-51.969, -49.19)) class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position # elems += i3.SRef(reference=markers_from_Rik(), # transformation=i3.Translation((x0, y0))) for j in range(0, 6, 1): elems += i3.SRef( reference=markers_from_Rik(name=("nima{}".format(j))), transformation=i3.Translation( (x0 + 5000 + 700 / 2, y0 - 2500 + 5000 * j))) elems += i3.SRef(reference=markers_from_Rik(), transformation=i3.Translation( (x0 + 5000 + 750 * 3 + 700 / 2, y0 - 2500 + 5000 * j))) elems += i3.SRef(reference=markers_from_Rik(), transformation=i3.Translation( (x0 + 5000 + 750 * 6 + 700 / 2, y0 - 2500 + 5000 * j))) elems += i3.SRef( reference=markers_from_Rik(name=("nimafan{}".format(j))), transformation=i3.Translation( (x0 - 5000 - 700 / 2, y0 - 2500 + 5000 * j))) elems += i3.SRef(reference=markers_from_Rik(), transformation=i3.Translation( (x0 - 5000 - 750 * 3 + 700 / 2, y0 - 2500 + 5000 * j))) elems += i3.SRef(reference=markers_from_Rik(), transformation=i3.Translation( (x0 - 5000 - 750 * 6 + 700 / 2, y0 - 2500 + 5000 * j))) return elems
class SiN_NP(i3.PCell): _name_prefix = "SiN_NP" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Layer layer = i3.LayerProperty(default=i3.TECH.PPLAYER.SIL.LINE) layer_bool = i3.LayerProperty(default=i3.TECH.PPLAYER.NONE.DOC) # Mesa parameters length = i3.PositiveNumberProperty(default=180.0) width = i3.PositiveNumberProperty(default=79.0) tilt = i3.PositiveNumberProperty(default=10.0) pillar = i3.BoolProperty(default=True) double = i3.BoolProperty(default=True) class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position elems += i3.Rectangle(layer=self.layer, center=(8750 - 15 - 10 + 5, 1500), box_size=(500 - 40, 1800 - 100)) elems += i3.Rectangle(layer=self.layer, center=(10500 - 15 - 10 + self.tilt / 2, 1500), box_size=(3000 + 50 + self.tilt, 450 - 15 * 2)) elems += i3.Rectangle(layer=self.layer, center=(8750 - 15 - 10 + 5 + 2420 - 150, 1000 - 120), box_size=(2000, 500 - 40)) # extra SiN pad # for i in range(4): # elems += i3.Rectangle(layer=self.layer, # center=( # 10000 - 725 - i * 750 + 2000 + 350, 1316+72.75), # box_size=(145, 77.5)) # elems += i3.Rectangle(layer=self.layer, center=( # 10000 - 725 - i * 750 + 2000 + 350, 1684-72.75), # change # box_size=(145, 77.5)) if self.pillar: for i in range(4): elems += i3.Rectangle( layer=self.layer_bool, center=(10000 - 725 - i * 750 + 2000 + 550, 1316 + self.width / 2 - 11.0 / 2), box_size=(self.length + 30, self.width + 30 + 11)) elems += i3.Rectangle( layer=self.layer_bool, center=(10000 - 725 - i * 750 + 2000 + 550, 1684 - self.width / 2 + 11.0 / 2), # change box_size=(self.length + 30, self.width + 30 + 11)) if self.double: elems += i3.Rectangle( layer=self.layer_bool, center=(10000 - 725 - i * 750 + 2000 + 550 - 400, 1316 + self.width / 2 - 11.0 / 2), box_size=(self.length + 30, self.width + 30 + 11)) elems += i3.Rectangle( layer=self.layer_bool, center=(10000 - 725 - i * 750 + 2000 + 550 - 400, 1684 - self.width / 2 + 11.0 / 2), # change box_size=(self.length + 30, self.width + 30 + 11)) # if self.tilt_0: # elems += i3.Rectangle(layer=self.layer, # center=(x0 + 6500 - 40 + 20 + 7.5, 2500), # box_size=(self.length + 40 + 15, self.width - 40 * 2)) # else: # elems += i3.Rectangle(layer=self.layer, # center=(x0 + 6500 - 40 + 20 + 5, 2500), # box_size=(self.length + 40 + 10, self.width - 40 * 2)) # # if self.pillar: # for i in range(7): # elems += i3.Rectangle(layer=self.layer_bool, # center=(10000 - 725 - i * 750, 1000 + (3000 - self.width) / 2 + 30), # box_size=(130, 140)) # elems += i3.Rectangle(layer=self.layer_bool, center=( # 10000 - 725 - i * 750, 1000 + (3000 - self.width) / 2 + self.width - 30), # box_size=(130, 140)) generated1 = self.layer - self.layer_bool mapping = {generated1: self.layer} elems = i3.get_elements_for_generated_layers(elems, mapping) return elems
class Coupon(i3.PCell): _name_prefix = "Coupon" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Coupon parameters length = i3.PositiveNumberProperty(default=40.0) width = i3.PositiveNumberProperty(default=8.0) shrink = i3.NumberProperty(default=0.0) # nb = i3.PositiveIntProperty(default=8) space = i3.PositiveNumberProperty(default=1000.0) class Layout(i3.LayoutView): # _name_prefix = "length{}".format(str(self.length)) def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position # RELEASE release = Release( length=self.length, width=self.width, ) # release = i3.Rectangle(layer=i3.Layer(number=1, name="release"), center=(0, 0), # box_size=(self.length, self.width)) # elems += i3.SRef(reference=release, position=self.position) Error dx = 918.125 # 800nm coupon for i in range(0, 3, 1): elems += i3.ARef(n_o_periods=(3, 7), period=(159.5, 210), reference=release, origin=(640.5 + i * dx, 468.4)) elems += i3.ARef(n_o_periods=(3, 7), period=(159.5, 210), reference=release, origin=(640.5 + i * dx, 538.4)) elems += i3.ARefY(n_o_periods_1d=7, period_1d=210, reference=release, origin=(560.75 + i * dx, 511.6)) dy = 1725 elems += i3.ARef(n_o_periods=(3, 15), period=(159.5, 210), reference=release, origin=(640.5 + i * dx, 468.4 + dy)) elems += i3.ARef(n_o_periods=(3, 15), period=(159.5, 210), reference=release, origin=(640.5 + i * dx, 538.4 + dy)) elems += i3.ARefY(n_o_periods_1d=15, period_1d=210, reference=release, origin=(560.75 + i * dx, 511.6 + dy)) dy = 5060 elems += i3.ARef(n_o_periods=(3, 15), period=(159.5, 210), reference=release, origin=(640.5 + i * dx, 468.4 + dy)) elems += i3.ARef(n_o_periods=(3, 15), period=(159.5, 210), reference=release, origin=(640.5 + i * dx, 538.4 + dy)) elems += i3.ARefY(n_o_periods_1d=15, period_1d=210, reference=release, origin=(560.75 + i * dx, 511.6 + dy)) dy = 8395 elems += i3.ARef(n_o_periods=(3, 8), period=(159.5, 210), reference=release, origin=(640.5 + i * dx, 468.4 + dy)) elems += i3.ARef(n_o_periods=(3, 7), period=(159.5, 210), reference=release, origin=(640.5 + i * dx, 538.4 + dy)) elems += i3.ARefY(n_o_periods_1d=7, period_1d=210, reference=release, origin=(560.75 + i * dx, 511.6 + dy)) dx += 200 # 1000nm coupon for i in range(0, 3, 1): elems += i3.ARef(n_o_periods=(4, 7), period=(167.6, 210), reference=release, origin=(3402.975 + i * dx, 468.4)) elems += i3.ARef(n_o_periods=(4, 7), period=(167.6, 210), reference=release, origin=(3402.975 + i * dx, 538.4)) elems += i3.ARefY(n_o_periods_1d=7, period_1d=210, reference=release, origin=(3319.175 + i * dx, 511.6)) dy = 1725 elems += i3.ARef(n_o_periods=(4, 15), period=(167.6, 210), reference=release, origin=(3402.975 + i * dx, 468.4 + dy)) elems += i3.ARef(n_o_periods=(4, 15), period=(167.6, 210), reference=release, origin=(3402.975 + i * dx, 538.4 + dy)) elems += i3.ARefY(n_o_periods_1d=15, period_1d=210, reference=release, origin=(3319.175 + i * dx, 511.6 + dy)) dy = 5060 elems += i3.ARef(n_o_periods=(4, 15), period=(167.6, 210), reference=release, origin=(3402.975 + i * dx, 468.4 + dy)) elems += i3.ARef(n_o_periods=(4, 15), period=(167.6, 210), reference=release, origin=(3402.975 + i * dx, 538.4 + dy)) elems += i3.ARefY(n_o_periods_1d=15, period_1d=210, reference=release, origin=(3319.175 + i * dx, 511.6 + dy)) dy = 8395 elems += i3.ARef(n_o_periods=(4, 8), period=(167.6, 210), reference=release, origin=(3402.975 + i * dx, 468.4 + dy)) elems += i3.ARef(n_o_periods=(4, 7), period=(167.6, 210), reference=release, origin=(3402.975 + i * dx, 538.4 + dy)) elems += i3.ARefY(n_o_periods_1d=7, period_1d=210, reference=release, origin=(3319.175 + i * dx, 511.6 + dy)) dx += 200 # 1200nm coupon for i in range(0, 3, 1): elems += i3.ARef(n_o_periods=(5, 7), period=(173, 210), reference=release, origin=(6762.75 + i * dx, 468.4)) elems += i3.ARef(n_o_periods=(5, 7), period=(173, 210), reference=release, origin=(6762.75 + i * dx, 538.4)) elems += i3.ARefY(n_o_periods_1d=7, period_1d=210, reference=release, origin=(6676.25 + i * dx, 511.6)) dy = 1725 elems += i3.ARef(n_o_periods=(5, 15), period=(173, 210), reference=release, origin=(6762.75 + i * dx, 468.4 + dy)) elems += i3.ARef(n_o_periods=(5, 15), period=(173, 210), reference=release, origin=(6762.75 + i * dx, 538.4 + dy)) elems += i3.ARefY(n_o_periods_1d=15, period_1d=210, reference=release, origin=(6676.25 + i * dx, 511.6 + dy)) dy = 5060 elems += i3.ARef(n_o_periods=(5, 15), period=(173, 210), reference=release, origin=(6762.75 + i * dx, 468.4 + dy)) elems += i3.ARef(n_o_periods=(5, 15), period=(173, 210), reference=release, origin=(6762.75 + i * dx, 538.4 + dy)) elems += i3.ARefY(n_o_periods_1d=15, period_1d=210, reference=release, origin=(6676.25 + i * dx, 511.6 + dy)) dy = 8395 elems += i3.ARef(n_o_periods=(5, 8), period=(173, 210), reference=release, origin=(6762.75 + i * dx, 468.4 + dy)) elems += i3.ARef(n_o_periods=(5, 7), period=(173, 210), reference=release, origin=(6762.75 + i * dx, 538.4 + dy)) elems += i3.ARefY(n_o_periods_1d=7, period_1d=210, reference=release, origin=(6676.25 + i * dx, 511.6 + dy)) return elems
class Obstacle_Left(i3.PCell): layer = i3.LayerProperty(default=i3.TECH.PPLAYER.CH2.TRENCH, doc='Layer to drawn on') # Properties of trap obstacle_trap_radius = i3.PositiveNumberProperty( default=10., doc="width or radius of obstacle") gap_btw_barriers = i3.PositiveNumberProperty(default=10., doc="gap between obstacles") cInp = i3.Coord2Property(default=(0.0, 0.0), required=True) class Layout(i3.LayoutView): def _generate_instances(self, insts): # First create shapes # Break the channel that contain two obstacles into three segments # Obstacles need to intersect these three segments # Obs 1. Segment 1:2, Obs 2 Segment 2:3 #define points will be helpful to make schematic p1 = (self.cInp.x + 0.0, self.cInp.y + 0.0) p2 = ((self.gap_btw_barriers * 0.5 + self.obstacle_trap_radius), 0.0) p3 = ((self.gap_btw_barriers * 0.5 + self.obstacle_trap_radius), self.gap_btw_barriers + self.obstacle_trap_radius * 2) p4 = (0.0, self.gap_btw_barriers + self.obstacle_trap_radius * 2) sr1 = i3.Shape(points=[p1, p2, p3, p4], closed=True) #Internal holes as Circles #to do: define position of SC2 as a function of perpendicular GAP sc1 = i3.ShapeCircle(center=(self.cInp.x + 0.0, self.gap_btw_barriers * 0.5 + self.obstacle_trap_radius), radius=(self.obstacle_trap_radius)) #Define the boundaries for shapes br1 = i3.Boundary(layer=self.layer, shape=sr1) bc1 = i3.Boundary(layer=self.layer, shape=sc1) #Substruct boundaries and add to the element list b_sub = br1 - bc1 s = i3.Structure(elements=b_sub) insts += i3.SRef(s) return insts #Thach added to define one inlet and one outlet def _generate_ports( self, ports): # Use _generate_ports method to define ports ports += i3.OpticalPort(name="in", position=(0., self.obstacle_trap_radius + self.gap_btw_barriers), angle=180.0) ports += i3.OpticalPort( name="out", position=((self.gap_btw_barriers * 1.5 + self.obstacle_trap_radius * 3), self.obstacle_trap_radius + self.gap_btw_barriers), angle=0.0) return ports
class Vacuum_BooleanBoundary(i3.PCell): layer = i3.LayerProperty(default=i3.TECH.PPLAYER.CH1.TRENCH, doc='Layer to drawn on') # Properties of vacuum feature_width = i3.PositiveNumberProperty(default=50., doc="width of trap") feature_height = i3.PositiveNumberProperty(default=50., doc="width of trap") gap_horiz = i3.PositiveNumberProperty(default=30., doc="width of obstacle") gap_vertical = i3.PositiveNumberProperty(default=30., doc="length of trap") vacuum_width = i3.PositiveNumberProperty(default=20., doc="gap between obstacles") cInp = i3.Coord2Property(default=(0.0, 0.0), required=True) class Layout(i3.LayoutView): def _generate_instances(self, insts): # First create shapes # Break the block containig the feature into two segments # Block need to intersect these two segments # Feature 1. Segment 1:2 #define points will be helpful to make schematic p1 = ((self.feature_width + self.gap_horiz + self.vacuum_width) * (-0.5), 0.0) p2 = (self.cInp.x + 0.0, self.cInp.y + 0.0) p3 = (self.cInp.x, self.feature_height * 0.5 + self.vacuum_width) p4 = ((self.feature_width + self.gap_horiz + self.vacuum_width) * (-0.5), self.feature_height * 0.5 + self.vacuum_width) p5 = ((self.feature_width + self.gap_horiz + self.vacuum_width) * (0.5), 0.0) p6 = ((self.feature_width + self.gap_horiz + self.vacuum_width) * (0.5), self.feature_height * 0.5 + self.vacuum_width) p7 = ((self.feature_width + self.gap_horiz + self.vacuum_width) * (-0.5), -(self.feature_height * 0.5 + self.vacuum_width)) p8 = (self.cInp.x, -(self.feature_height * 0.5 + self.vacuum_width)) p9 = ((self.feature_width + self.gap_horiz + self.vacuum_width) * (0.5), -(self.feature_height * 0.5 + self.vacuum_width)) sr1 = i3.Shape(points=[p1, p2, p3, p4], closed=True) sr2 = i3.Shape(points=[p2, p5, p6, p3], closed=True) sr3 = i3.Shape(points=[p7, p8, p2, p1], closed=True) sr4 = i3.Shape(points=[p8, p9, p5, p2], closed=True) #Internal holes as Circles #It is needed to define position of SC2 as a function of perpendicular GAP #sc1 = i3.ShapeCircle(center = (self.cInp.x+(self.gap_btw_barriers+self.obstacle_trap_length)*0.65, 0.0), radius = (self.obstacle_trap_width)) #sc2 = i3.ShapeCircle(center = (self.cInp.x+(self.gap_btw_barriers+self.obstacle_trap_length)*1.35,self.cInp.y+self.channel_trap_width), radius = (self.obstacle_trap_width)) #Internal holes as Rectangles sc1 = i3.ShapeRectangle( center=(self.cInp.x, self.cInp.y), box_size=(self.feature_width + self.gap_horiz, self.feature_height + self.gap_vertical)) #Define the boundaries for shapes br1 = i3.Boundary(layer=self.layer, shape=sr1) br2 = i3.Boundary(layer=self.layer, shape=sr2) br3 = i3.Boundary(layer=self.layer, shape=sr3) br4 = i3.Boundary(layer=self.layer, shape=sr4) bc1 = i3.Boundary(layer=self.layer, shape=sc1) #Substruct boundaries and add to the element list b_sub = br1 - bc1 s = i3.Structure(elements=b_sub) insts += i3.SRef(s) b_sub = br2 - bc1 b_sub = b_sub[0] - bc1 s = i3.Structure(elements=b_sub) insts += i3.SRef(s) b_sub = br3 - bc1 s = i3.Structure(elements=b_sub) insts += i3.SRef(s) b_sub = br4 - bc1 s = i3.Structure(elements=b_sub) insts += i3.SRef(s) return insts #Thach added to define one inlet and one outlet def _generate_ports( self, ports): # Use _generate_ports method to define ports ''' #ports += i3.InFluidicPort(name = "in", position = (0., 10.), angle = 180.0) ports += i3.OpticalPort(name = "in", position = (0., self.channel_trap_width*0.5), angle = 180.0) #ports += i3.OutFluidicPort(name ="out", position = (30., 10.), angle = 0.0) ports += i3.OpticalPort(name ="out", position = ((self.obstacle_trap_length+self.gap_btw_barriers)*2, self.channel_trap_width*0.5), angle = 0.0) ''' return ports
class Coupon2(i3.PCell): _name_prefix = "Coupon2" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Coupon parameters length = i3.PositiveNumberProperty(default=2750.0) width = i3.PositiveNumberProperty(default=85.0) class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position # RELEASE c1 = Coupon(length=2750, nb=16) #2750 label A no need for shrink elems += i3.SRef(reference=c1, position=self.position, transformation=i3.Translation( (0, 0)) + i3.Translation((-16000, -25000))) elems += i3.PolygonText(layer=i3.Layer(number=4, name="release"), text="A16", font=2, height=1000.0, transformation=i3.Translation( (45075, -12500))) c2 = Coupon(length=2250, shrink=500, nb=16) elems += i3.SRef(reference=c2, position=self.position, transformation=i3.Translation( (0, 23240)) + i3.Translation( (-16000, -25000))) elems += i3.PolygonText(layer=i3.Layer(number=4, name="release"), text="B16", font=2, height=200.0, transformation=i3.Translation( (35865, 20437.5))) c3 = Coupon(length=1500, shrink=1250, nb=16) elems += i3.SRef(reference=c3, position=self.position, transformation=i3.Translation( (0, 46480)) + i3.Translation( (-16000, -25000))) elems += i3.PolygonText(layer=i3.Layer(number=4, name="release"), text="C16", font=2, height=1000.0, transformation=i3.Translation( (-10000, 46677.5))) c4 = Coupon(length=2750, nb=8) elems += i3.SRef(reference=c4, position=self.position, transformation=i3.Translation((-28000, -38160))) elems += i3.PolygonText(layer=i3.Layer(number=4, name="release"), text="A8", font=2, height=1000.0, transformation=i3.Translation( (32650, -30000))) c5 = Coupon(length=2250, shrink=500, nb=12) elems += i3.SRef(reference=c5, position=self.position, transformation=i3.Rotation(rotation=90) + i3.Translation((-18417.5, -23917.5))) elems += i3.PolygonText(layer=i3.Layer(number=4, name="release"), text="B12", font=2, height=1000.0, transformation=i3.Translation( (-27695, 29707.5))) c6 = Coupon(length=1500, shrink=1250, nb=10) elems += i3.SRef(reference=c6, position=self.position, transformation=i3.Rotation(rotation=90) + i3.Translation((-36617.5, -23917.5))) elems += i3.PolygonText(layer=i3.Layer(number=4, name="release"), text="C10", font=2, height=1000.0, transformation=i3.Translation( (-40000, 18832.5))) c7 = Coupon(length=1500, shrink=1250, nb=10) elems += i3.SRef(reference=c7, position=self.position, transformation=i3.Translation((-22000, -53840))) elems += i3.PolygonText(layer=i3.Layer(number=4, name="release"), text="C10", font=2, height=1000.0, transformation=i3.Translation( (20950, -41500))) c8 = Coupon(length=2250, shrink=500, nb=14) elems += i3.SRef(reference=c8, position=self.position, transformation=i3.Translation((38750, -1760))) elems += i3.PolygonText(layer=i3.Layer(number=4, name="release"), text="B14", font=2, height=1000.0, transformation=i3.Translation( (48000, -3802.5))) c9 = Coupon(length=1500, shrink=1250, nb=14) elems += i3.SRef(reference=c9, position=self.position, transformation=i3.Translation((27500, 21480))) elems += i3.PolygonText(layer=i3.Layer(number=4, name="release"), text="C14", font=2, height=200.0, transformation=i3.Translation( (44000, 20437.5))) elems += i3.Circle(layer=i3.Layer(number=5, name="tether"), center=(0.0, 0.0), radius=50000) return elems
class AlignmentMarkerSet(i3.PCell): _name_prefix = "ALIGNMENT MARKER SET" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Orientation horizontal = i3.BoolProperty(default=True) # Spacing v_spacing = i3.PositiveNumberProperty(default=320.0) h_spacing = i3.PositiveNumberProperty(default=300.0) class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position if self.horizontal == False: # ADD RELEASE elems += i3.SRef(reference=AlignmentMarker( layer=i3.TECH.PPLAYER.WG.TEXT, layer_text="Release"), transformation=i3.Translation( (x0 + 0.0 * self.h_spacing, y0))) elems += i3.SRef(reference=AlignmentMarker( layer=i3.TECH.PPLAYER.HFW, complement=True), transformation=i3.Translation( (x0 + 0.0 * self.h_spacing, y0))) # # ADD TETHER # elems += i3.SRef(reference=AlignmentMarker(layer=lay_island, layer_text="Tether"), # transformation=i3.Translation((x0 + 1.0 * self.h_spacing, y0))) # elems += i3.SRef(reference=AlignmentMarker(layer=lay_release, protection=True), # transformation=i3.Translation((x0 + 1.0 * self.h_spacing, y0))) # elems += i3.SRef(reference=AlignmentMarker(layer=lay_tether, complement=True), # transformation=i3.Translation((x0 + 1.0 * self.h_spacing, y0))) # # # ADD Dongbomesa # elems += i3.SRef(reference=AlignmentMarker(layer=lay_island, layer_text="Dongbomesa"), # transformation=i3.Translation((x0 + 2.0 * self.h_spacing, y0))) # elems += i3.SRef(reference=AlignmentMarker(layer=lay_release, protection=True), # transformation=i3.Translation((x0 + 2.0 * self.h_spacing, y0))) # elems += i3.SRef(reference=AlignmentMarker(layer=lay_tether, protection=True), # transformation=i3.Translation((x0 + 2.0 * self.h_spacing, y0))) # elems += i3.SRef(reference=AlignmentMarker(layer=lay_mesa, complement=True), # transformation=i3.Translation((x0 + 2.0 * self.h_spacing, y0))) else: # ADD RECESS elems += i3.SRef(reference=AlignmentMarker( layer=i3.TECH.PPLAYER.WG.TEXT, layer_text="RECESS"), transformation=i3.Translation( (x0 + 0.0 * self.h_spacing, y0))) elems += i3.SRef(reference=AlignmentMarker( layer=i3.TECH.PPLAYER.HFW, complement=True), transformation=i3.Translation( (x0 + 0.0 * self.h_spacing, y0))) # ADD AL elems += i3.SRef(reference=AlignmentMarker( layer=i3.TECH.PPLAYER.WG.TEXT, layer_text="AL"), transformation=i3.Translation( (x0, y0 - 1.0 * self.v_spacing))) elems += i3.SRef(reference=AlignmentMarker( layer=i3.TECH.PPLAYER.HFW, protection=True), transformation=i3.Translation( (x0, y0 - 1.0 * self.v_spacing))) elems += i3.SRef(reference=AlignmentMarker( layer=i3.TECH.PPLAYER.CONTACT.PILLAR, complement=True), transformation=i3.Translation( (x0, y0 - 1.0 * self.v_spacing))) # ADD SiN elems += i3.SRef(reference=AlignmentMarker( layer=i3.TECH.PPLAYER.WG.TEXT, layer_text="SiN"), transformation=i3.Translation( (x0, y0 - 2.0 * self.v_spacing))) elems += i3.SRef(reference=AlignmentMarker( layer=i3.TECH.PPLAYER.HFW, protection=True), transformation=i3.Translation( (x0, y0 - 2.0 * self.v_spacing))) elems += i3.SRef(reference=AlignmentMarker( layer=i3.TECH.PPLAYER.SIL.LINE, complement=True), transformation=i3.Translation( (x0, y0 - 2.0 * self.v_spacing))) # ADD BackUp elems += i3.SRef(reference=AlignmentMarker( layer=i3.TECH.PPLAYER.WG.TEXT, layer_text="BackUp"), transformation=i3.Translation( (x0, y0 - 3.0 * self.v_spacing))) elems += i3.SRef(reference=AlignmentMarker( layer=i3.TECH.PPLAYER.HFW, protection=True), transformation=i3.Translation( (x0, y0 - 3.0 * self.v_spacing))) # elems += i3.SRef(reference=AlignmentMarker(layer=lay_tether, complement=True), # transformation=i3.Translation((x0, y0 - 3.0 * self.v_spacing))) # RECESS adjustment according to the mask elems += i3.SRef(reference=AlignmentMarker( layer=i3.TECH.PPLAYER.NONE.DOC, protection=True), transformation=i3.Translation( (x0, y0 - 0.0 * self.v_spacing))) generated1 = i3.TECH.PPLAYER.NONE.DOC - i3.TECH.PPLAYER.HFW mapping = {generated1: i3.TECH.PPLAYER.V12.PILLAR} elems += i3.get_elements_for_generated_layers(elems, mapping) return elems
class Coupon(i3.PCell): _name_prefix = "Coupon" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Coupon parameters length = i3.PositiveNumberProperty(default=2750.0) width = i3.PositiveNumberProperty(default=85.0) shrink = i3.NumberProperty(default=0.0) nb = i3.PositiveIntProperty(default=8) space = i3.PositiveNumberProperty(default=1000.0) class Layout(i3.LayoutView): # _name_prefix = "length{}".format(str(self.length)) def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position # RELEASE release = Release( length=self.length, width=self.width, ) # elems += i3.SRef(reference=release, position=self.position) elems += i3.ARef(n_o_periods=(3, self.nb), period=(self.length + 250, 210), reference=release, origin=(x0, y0)) elems += i3.ARef(n_o_periods=(3, self.nb), period=(self.length + 250, 280), reference=release, origin=(x0, y0 + 210 * self.nb - (210 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(3, self.nb), period=(self.length + 250, 350), reference=release, origin=(x0, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(3, self.nb), period=(self.length + 250, 420), reference=release, origin=(x0, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space + 350 * self.nb - (350 - self.width) + self.space)) elems += i3.ARef(n_o_periods=(2, self.nb), period=(self.length + 500, 210), reference=release, origin=(x0 + 9250 - self.shrink * 3, y0)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 500, 280), reference=release, origin=(x0 + 9250 - self.shrink * 3, y0 + 210 * self.nb - (210 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 500, 350), reference=release, origin=(x0 + 9250 - self.shrink * 3, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 500, 420), reference=release, origin=(x0 + 9250 - self.shrink * 3, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space + 350 * self.nb - (350 - self.width) + self.space)) elems += i3.ARef(n_o_periods=(2, self.nb), period=(self.length + 750, 210), reference=release, origin=(x0 + 8000 * 2 - self.shrink * 5, y0)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 750, 280), reference=release, origin=(x0 + 8000 * 2 - self.shrink * 5, y0 + 210 * self.nb - (210 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 750, 350), reference=release, origin=(x0 + 8000 * 2 - self.shrink * 5, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 750, 420), reference=release, origin=(x0 + 8000 * 2 - self.shrink * 5, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space + 350 * self.nb - (350 - self.width) + self.space)) elems += i3.ARef(n_o_periods=(2, self.nb), period=(self.length + 1000, 210), reference=release, origin=(x0 + 23250 - self.shrink * 7, y0)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 1000, 280), reference=release, origin=(x0 + 23250 - self.shrink * 7, y0 + 210 * self.nb - (210 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 1000, 350), reference=release, origin=(x0 + 23250 - self.shrink * 7, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 1000, 420), reference=release, origin=(x0 + 23250 - self.shrink * 7, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space + 350 * self.nb - (350 - self.width) + self.space)) elems += i3.ARef(n_o_periods=(2, self.nb), period=(self.length + 1500, 210), reference=release, origin=(x0 + 29750 + 1500 - self.shrink * 9, y0)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 1500, 280), reference=release, origin=(x0 + 29750 + 1500 - self.shrink * 9, y0 + 210 * self.nb - (210 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 1500, 350), reference=release, origin=(x0 + 29750 + 1500 - self.shrink * 9, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 1500, 420), reference=release, origin=(x0 + 29750 + 1500 - self.shrink * 9, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space + 350 * self.nb - (350 - self.width) + self.space)) elems += i3.ARef(n_o_periods=(2, self.nb), period=(self.length + 2000, 210), reference=release, origin=(x0 + 38250 + 2000 - self.shrink * 11, y0)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 2000, 280), reference=release, origin=(x0 + 38250 + 2000 - self.shrink * 11, y0 + 210 * self.nb - (210 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 2000, 350), reference=release, origin=(x0 + 38250 + 2000 - self.shrink * 11, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 2000, 420), reference=release, origin=(x0 + 38250 + 2000 - self.shrink * 11, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space + 350 * self.nb - (350 - self.width) + self.space)) elems += i3.ARef(n_o_periods=(2, self.nb), period=(self.length + 3000, 210), reference=release, origin=(x0 + 47750 + 3000 - self.shrink * 13, y0)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 3000, 280), reference=release, origin=(x0 + 47750 + 3000 - self.shrink * 13, y0 + 210 * self.nb - (210 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 3000, 350), reference=release, origin=(x0 + 47750 + 3000 - self.shrink * 13, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space)) elems += i3.ARef( n_o_periods=(2, self.nb), period=(self.length + 3000, 420), reference=release, origin=(x0 + 47750 + 3000 - self.shrink * 13, y0 + 210 * self.nb - (210 - self.width) + self.space + 280 * self.nb - (280 - self.width) + self.space + 350 * self.nb - (350 - self.width) + self.space)) # elems += i3.Circle(layer=i3.Layer(number = 5, name = "tether"),radius=50000) return elems
class Obstacle_BooleanBoundary(i3.PCell): layer = i3.LayerProperty(default=i3.TECH.PPLAYER.CH1.TRENCH, doc='Layer to drawn on') # Properties of trap channel_trap_width = i3.PositiveNumberProperty(default=50., doc="width of trap") obstacle_trap_width = i3.PositiveNumberProperty(default=25., doc="width of obstacle") obstacle_trap_length = i3.PositiveNumberProperty(default=30., doc="length of trap") gap_btw_barriers = i3.PositiveNumberProperty(default=20., doc="gap between obstacles") cInp = i3.Coord2Property(default = (0.0,0.0),required = True) class Layout(i3.LayoutView): def _generate_instances(self, insts): # First create shapes # Break the channel that contain two obstacles into three segments # Obstacles need to intersect these three segments # Obs 1. Segment 1:2, Obs 2 Segment 2:3 #define points will be helpful to make schematic p1 = (self.cInp.x+0.0,self.cInp.y+0.0) p2 = ((self.gap_btw_barriers+self.obstacle_trap_length)*0.5,0.0) p3 = ((self.gap_btw_barriers+self.obstacle_trap_length)*0.5,self.channel_trap_width) p4 = (0.0,self.channel_trap_width) p5 = ((self.gap_btw_barriers+self.obstacle_trap_length)*1.5, 0.0) p6 = ((self.gap_btw_barriers+self.obstacle_trap_length)*2, 0.0) p7 = ((self.gap_btw_barriers+self.obstacle_trap_length)*2, self.channel_trap_width) p8 = ((self.gap_btw_barriers+self.obstacle_trap_length)*1.5,self.channel_trap_width) sr1 = i3.Shape(points = [p1,p2,p3,p4], closed =True) sr2 = i3.Shape(points = [p2,p5,p8,p3], closed =True) sr3 = i3.Shape(points = [p5,p6,p7,p8], closed =True) #Internal holes as Circles #to do: define position of SC2 as a function of perpendicular GAP sc1 = i3.ShapeCircle(center = (self.cInp.x+(self.gap_btw_barriers+self.obstacle_trap_length)*0.65, 0.0), radius = (self.obstacle_trap_width)) sc2 = i3.ShapeCircle(center = (self.cInp.x+(self.gap_btw_barriers+self.obstacle_trap_length)*1.35,self.cInp.y+self.channel_trap_width), radius = (self.obstacle_trap_width)) #Internal holes as Rectangles ''' sc1 = i3.ShapeRectangle(center = (self.cInp.x+(self.gap_btw_barriers +self.obstacle_trap_length)*0.5, self.cInp.y+self.obstacle_trap_width*0.5), box_size = (self.obstacle_trap_length, self.obstacle_trap_width)) sc2 = i3.ShapeRectangle(center = (self.cInp.x+(self.gap_btw_barriers +self.obstacle_trap_length)*1.5, self.cInp.y+self.channel_trap_width-self.obstacle_trap_width*0.5), box_size = (self.obstacle_trap_length, self.obstacle_trap_width)) ''' #Define the boundaries for shapes br1 = i3.Boundary(layer = self.layer, shape = sr1) br2 = i3.Boundary(layer = self.layer, shape = sr2) br3 = i3.Boundary(layer = self.layer, shape = sr3) bc1 = i3.Boundary(layer = self.layer, shape = sc1) bc2 = i3.Boundary(layer = self.layer, shape = sc2) #Substruct boundaries and add to the element list b_sub = br1-bc1 s= i3.Structure(elements = b_sub) insts += i3.SRef(s) b_sub = br2-bc1 b_sub = b_sub[0] - bc2 s= i3.Structure(elements = b_sub) insts += i3.SRef(s) b_sub = br3-bc2 s= i3.Structure(elements = b_sub) insts += i3.SRef(s) return insts #Thach added to define one inlet and one outlet def _generate_ports(self, ports): # Use _generate_ports method to define ports #ports += i3.InFluidicPort(name = "in", position = (0., 10.), angle = 180.0) ports += i3.OpticalPort(name = "in", position = (0., self.channel_trap_width*0.5), angle = 180.0) #ports += i3.OutFluidicPort(name ="out", position = (30., 10.), angle = 0.0) ports += i3.OpticalPort(name ="out", position = ((self.obstacle_trap_length+self.gap_btw_barriers)*2, self.channel_trap_width*0.5), angle = 0.0) return ports
class Heater(i3.PCell): _name_prefix = "Heater" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Layer layer = i3.LayerProperty(default=i3.TECH.PPLAYER.N.LINE) layer_bool = i3.LayerProperty(default=i3.TECH.PPLAYER.NONE.DOC) layer2 = i3.LayerProperty(default=i3.TECH.PPLAYER.FC.TRENCH) layer3 = i3.LayerProperty(default=i3.TECH.PPLAYER.FC.HOLE) # Mesa parameters length = i3.PositiveNumberProperty(default=180.0) width = i3.PositiveNumberProperty(default=150.0) class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position elems += i3.Rectangle(layer=self.layer, center=(6250, -500), box_size=(500, 500)) elems += i3.Rectangle(layer=self.layer, center=(6250, 1000), box_size=(500, 500)) elems += i3.Rectangle(layer=self.layer2, center=(9950, 1000), box_size=(4100, self.width)) # heaters elems += i3.Rectangle(layer=self.layer3, center=(9950, 1000), box_size=(3900, self.width+20)) # heaters during plating elems += i3.Rectangle(layer=self.layer, center=(9950 - 4100 / 2+50, 1000), box_size=(100, self.width)) # heaters butt left elems += i3.Rectangle(layer=self.layer, center=(9950 + 4100 / 2 - 50, 1000), box_size=(100, self.width)) # heaters butt right elems += i3.Rectangle(layer=self.layer, center=(9950 - 4100 / 2 + 50-750, 1000), box_size=(1400, 100)) # left elems += i3.Rectangle(layer=self.layer, center=(9950 - 4100 / 2 + 50 - 750-450, -500), box_size=(500, 100)) elems += i3.Rectangle(layer=self.layer, center=(9950 + 4100 / 2 - 50, 1000 - (500+self.width) / 2), box_size=(100, 500)) elems += i3.Rectangle(layer=self.layer, center=(9450, 1000-self.width/2-450), box_size=(4900, 100)) elems += i3.Rectangle(layer=self.layer, center=(5050 + 4100 / 2 - 50, -550+(1000-self.width/2+50)/2), box_size=(100, 1000-self.width/2+50)) elems += i3.PolygonText(layer=i3.TECH.PPLAYER.WG.TEXT, text="width_{}".format(self.width), # coordinate=(1300.0, 100.0), alignment=(i3.TEXT_ALIGN_LEFT, i3.TEXT_ALIGN_LEFT), font=2, height=400.0, transformation=i3.Translation((8000, 0)) ) return elems
class NP_mmi12(i3.PCell): _name_prefix = "NP_" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Layer layer = i3.LayerProperty(default=i3.TECH.PPLAYER.HFW) layer_bool = i3.LayerProperty(default=i3.TECH.PPLAYER.NONE.DOC) layer2 = i3.LayerProperty(default=i3.TECH.PPLAYER.WG.TEXT) # Mesa parameters length = i3.PositiveNumberProperty(default=160.0) width = i3.PositiveNumberProperty(default=120.0) pillar = i3.BoolProperty(default=False) pocket = i3.BoolProperty(default=False) tilt = i3.BoolProperty(default=False) double = i3.BoolProperty(default=True) # Recess label label = i3.StringProperty(default="NP") class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position width2 = 450.0 elems += i3.Rectangle(layer=self.layer, center=(x0 + 6500 + 2000 + 2000, 600 + (1800 - width2) / 4), box_size=(3000, (1800 - width2) / 2)) elems += i3.Rectangle(layer=self.layer, center=(x0 + 6500 + 2000 + 2000, y0 + 600 + width2 + (1800 - width2) * 3 / 4), box_size=(3000, (1800 - width2) / 2)) elems += i3.SRef( reference=Interface_mmi12(pocket=self.pocket, tilt=self.tilt)) if self.pillar: self.label = "NO" for i in range(4): elems += i3.Rectangle( layer=self.layer, center=(10000 - 725 - i * 750 + 2000 + 550, 1275 + self.width / 2), box_size=(self.length, self.width)) elems += i3.Rectangle( layer=self.layer, center=(10000 - 725 - i * 750 + 2000 + 550, 1725 - self.width / 2), # change box_size=(self.length, self.width)) if self.double: elems += i3.Rectangle( layer=self.layer, center=(10000 - 725 - i * 750 + 2000 + 550 - 400, 1275 + self.width / 2), box_size=(self.length, self.width)) elems += i3.Rectangle( layer=self.layer, center=(10000 - 725 - i * 750 + 2000 + 550 - 400, 1725 - self.width / 2), # change box_size=(self.length, self.width)) if self.width > 120: self.label += "W" if self.pocket: self.label += "_WP" if self.tilt: self.label += "WT" elems += i3.PolygonText( layer=self.layer_bool, text=self.label, coordinate=(10800, 2600), # alignment=(i3.TEXT_ALIGN_LEFT, i3.TEXT_ALIGN_LEFT), font=2, height=400.0) generated1 = self.layer - self.layer_bool mapping = {generated1: self.layer} elems = i3.get_elements_for_generated_layers(elems, mapping) if self.pillar: for i in range(4): elems += i3.Rectangle( layer=self.layer2, center=(10000 - 725 - i * 750 + 2000 + 550, 1275 + self.width / 2), box_size=(self.length + 10, self.width + 10)) elems += i3.Rectangle( layer=self.layer2, center=(10000 - 725 - i * 750 + 2000 + 550, 1725 - self.width / 2), # change box_size=(self.length + 10, self.width + 10)) if self.double: elems += i3.Rectangle( layer=self.layer2, center=(10000 - 725 - i * 750 + 2000 + 550 - 400, 1275 + self.width / 2), box_size=(self.length + 10, self.width + 10)) elems += i3.Rectangle( layer=self.layer2, center=(10000 - 725 - i * 750 + 2000 + 550 - 400, 1725 - self.width / 2), # change box_size=(self.length + 10, self.width + 10)) return elems
class label(i3.PCell): _name_prefix = "label" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Layer layer = i3.LayerProperty(default=i3.TECH.PPLAYER.HFW) # layer_bool = i3.LayerProperty(default=i3.TECH.PPLAYER.NONE.DOC) class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position x = 6200 y = 8000 Height = 300 elems += i3.PolygonText(layer=self.layer, text="1N", # coordinate=(1300.0, 100.0), # alignment=(i3.TEXT_ALIGN_LEFT, i3.TEXT_ALIGN_LEFT), font=2, height=Height, transformation=i3.Translation((x0, y0)) ) elems += i3.PolygonText(layer=self.layer, text="5J", # coordinate=(1300.0, 100.0), # alignment=(i3.TEXT_ALIGN_LEFT, i3.TEXT_ALIGN_LEFT), font=2, height=Height, transformation=i3.Translation((x0 + 1 * x, y0 + 1 * y+700)) ) elems += i3.PolygonText(layer=self.layer, text="4W", # coordinate=(1300.0, 100.0), # alignment=(i3.TEXT_ALIGN_LEFT, i3.TEXT_ALIGN_LEFT), font=2, height=Height, transformation=i3.Translation((x0 + 0 * x, y0 + 1 * y)) ) elems += i3.PolygonText(layer=self.layer, text="2E", # coordinate=(1300.0, 100.0), # alignment=(i3.TEXT_ALIGN_LEFT, i3.TEXT_ALIGN_LEFT), font=2, height=Height, transformation=i3.Translation((x0 + 1 * x, y0 + 0 * y+1100)) ) elems += i3.PolygonText(layer=self.layer, text="3W", # coordinate=(1300.0, 100.0), # alignment=(i3.TEXT_ALIGN_LEFT, i3.TEXT_ALIGN_LEFT), font=2, height=Height, transformation=i3.Translation((x0 + 2 * x, y0 + 0 * y)) ) elems += i3.PolygonText(layer=self.layer, text="6E", # coordinate=(1300.0, 100.0), # alignment=(i3.TEXT_ALIGN_LEFT, i3.TEXT_ALIGN_LEFT), font=2, height=Height, transformation=i3.Translation((x0 + 2 * x, y0 + 1 * y)) ) return elems
class CellTrapRounded(CellTrapSimple): """ Provide a decription of this PCell What is the difference between this and CellTrapSimple? """ _name_prefix = "CELLTRAP_ROUNDED" # a prefix added to the unique identifier cInp = i3.Coord2Property( default=(0.0, 0.0), doc="Center of trap, reference point needed to define rounded corner") class Layout(CellTrapSimple.Layout): ''' ----------------------------\ /-------------- in angle \ / outangle \ / |_____| |-funnel length-| _____ . . . . . . . . . . _____________________. .__________ ###UNDER CONSTRUCTION ''' funnel_length = i3.NumberProperty(default=100.0, doc="Francisoc: What is this?") def _generate_elements(self, elems): cell_trap_width = self.channel_template.channel_width entry_Lfd = self.cell_trap_length * 0.5 # 1000.0 exit_Lfd = self.cell_trap_length * 0.5 # 500.0 beta = math.radians(self.out_angle) lf = self.funnel_length wi = cell_trap_width wf = self.cell_trap_gap #lfd = 0 taper_samples = 200 a = lf / (wi / wf - 1.0) dx = lf / taper_samples x = 0.0 xl = [] wl = [] point_list = [] x_offset = self.funnel_length + self.cell_trap_gap_length # all expansion will be at 0.0x a = 0.5 b = .35 point_list.append( self.cInp + (-(self.cell_trap_length * b), wi * 0.5)) # end of array point_list.insert(0, self.cInp + (-(self.cell_trap_length * b), -wi * 0.5)) # begging of array, position 0 for i in reversed(range(1, taper_samples + 1)): #xa = lf * math.exp(10.0 * (i / taper_samples - 1.0)) #discretization radius = 0.5 * wi ### this needs to be improved xa = (radius) * math.cos(0.5 * math.pi * i / taper_samples) #w = wi / (1.0 + xa / a) #function value w = (radius) * math.sin(0.5 * math.pi * i / taper_samples) p = (xa - radius - self.cell_trap_gap_length * 0.5, 0.5 * (w + 0.5 * wi)) point_list.append(self.cInp + p) p = (xa - radius - self.cell_trap_gap_length * 0.5, -0.5 * (w + 0.5 * wi)) point_list.insert(0, self.cInp + p) # GAP LENGTH p = ( point_list[-1][0], wf * 0.5 ) #wGet last point, coordX use it for next point with wf as coordY point_list.append(self.cInp + p) # Insert it at the bottom of point_list p = point_list[-1] + (0.0, (-wf)) # Get last point, add -wf point_list.insert(0, self.cInp + p) # Insert it at the bottom of point_list p = point_list[-1] + (self.cell_trap_gap_length, 0.0 ) # Get last point and add length point_list.append(self.cInp + p) # Insert it at [0] in the point_list p = point_list[-1] + (0.0, -wf) # Get last point and add length point_list.insert(0, self.cInp + p) # Insert it at [0] in the point_list # EXIT ANGLE p = point_list[-1] + ( 0.5 * (cell_trap_width - self.cell_trap_gap) / math.tan(beta), -cell_trap_width * 0.5 - wf * .50 ) # Get last point and add length of angle point_list.insert(0, self.cInp + p) # Insert it at [0] in the point_list p = point_list[0] + (0, wi) point_list.append(self.cInp + p) # Insert it at the bottom of point_list # EXIT LENGTH p = (self.cell_trap_length * b, point_list[-1][1] ) # get first point (last point added) and add length point_list.append(self.cInp + p) p = point_list[-1] + (0, -wi) ##get last point and add length point_list.insert(0, self.cInp + p) t = i3.Shape(point_list, closed=True) rectang = i3.ShapeRound(original_shape=t, start_face_angle=0, end_face_angle=0, radius=self.radius_fillet) bo = i3.Boundary(self.channel_template.layer, rectang) #creating an inlet rectangle boundary to avoid round corners point_list = [] point_list.append( (-self.cell_trap_length * a, -cell_trap_width * 0.5)) point_list.insert( 0, (-self.cell_trap_length * a, cell_trap_width * 0.5)) point_list.append((-self.cell_trap_length * b + self.radius_fillet, -cell_trap_width * 0.5)) point_list.insert(0, (-self.cell_trap_length * b + self.radius_fillet, cell_trap_width * 0.5)) t = i3.Shape(point_list, closed=True) bo1 = i3.Boundary(self.channel_template.layer, t) #creating an outlet rectangle boundary to avoid round corners point_list = [] point_list.append((self.cell_trap_length * b - self.radius_fillet, -cell_trap_width * 0.5)) point_list.insert(0, (self.cell_trap_length * b - self.radius_fillet, cell_trap_width * 0.5)) point_list.append( (self.cell_trap_length * a, -cell_trap_width * 0.5)) point_list.insert( 0, (self.cell_trap_length * a, cell_trap_width * 0.5)) t = i3.Shape(point_list, closed=True) bo2 = i3.Boundary(self.channel_template.layer, t) #boolean operation adding main geometry and inlet rectangle b_add = bo | bo1 #boolean operation adding main geometry and outlet rectangle b_add2 = b_add[0] | bo2 #s2 = i3.Structure(elements=b_add2) elems += b_add2 #insts += bo return elems def _generate_ports(self, ports): #port1 ports += microfluidics.FluidicPort( name='in1', position=(-self.cell_trap_length * 0.5, 0.0), direction=i3.PORT_DIRECTION.IN, #angle_deg=0, trace_template=self.channel_template) ports += microfluidics.FluidicPort( name='out1', position=(self.cell_trap_length * 0.5, 0.0), direction=i3.PORT_DIRECTION.IN, #angle_deg=0, trace_template=self.channel_template) return ports
class AlignmentMarker(i3.PCell): _name_prefix = "ALIGNMENT MARKER" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Layer layer = i3.LayerProperty(required=True) # Complement complement = i3.BoolProperty(default=False) # Protection protection = i3.BoolProperty(default=False) # Marker parameters cross_length = i3.PositiveNumberProperty(default=150.0) cross_width = i3.PositiveNumberProperty(default=16.0) cross_margin = i3.PositiveNumberProperty(default=4.0) vernier_length = i3.PositiveNumberProperty(default=30.0) vernier_width = i3.PositiveNumberProperty(default=8.0) vernier_period = i3.PositiveNumberProperty(default=20.25) vernier_left_center = i3.Coord2Property(default=(-121.0, 24.0)) vernier_top_center = i3.Coord2Property(default=(-6.0, 119.0)) vernier_complement_length = i3.PositiveNumberProperty(default=18.0) vernier_complement_long_length = i3.PositiveNumberProperty(default=28.0) vernier_complement_width = i3.PositiveNumberProperty(default=10.0) vernier_complement_shift = i3.PositiveNumberProperty(default=9.0) vernier_complement_period = i3.PositiveNumberProperty(default=20) protection_length = i3.PositiveNumberProperty(default=300.0) protection_width = i3.PositiveNumberProperty(default=320.0) # Layer text layer_text = i3.StringProperty(default="Mesa") class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position shift = 0.5 * self.cross_width + self.cross_margin square_length = 0.5 * self.cross_length - shift if (self.complement == False and self.protection == False): # Add cross elems += i3.Rectangle(layer=self.layer, center=(x0, y0), box_size=(self.cross_length, self.cross_width)) elems += i3.Rectangle(layer=self.layer, center=(x0, y0), box_size=(self.cross_width, self.cross_length)) # Add rectangles left VERNIER elems += i3.Rectangle(layer=self.layer, center=(self.vernier_left_center[0], self.vernier_left_center[1]), box_size=(self.vernier_length, self.vernier_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0], self.vernier_left_center[1] + self.vernier_period), box_size=(self.vernier_length, self.vernier_width)) elems += i3.Rectangle(layer=self.layer, center=(self.vernier_left_center[0], self.vernier_left_center[1] + 2.0 * self.vernier_period), box_size=(self.vernier_length, self.vernier_width)) elems += i3.Rectangle(layer=self.layer, center=(self.vernier_left_center[0], self.vernier_left_center[1] + 3.0 * self.vernier_period), box_size=(self.vernier_length, self.vernier_width)) elems += i3.Rectangle(layer=self.layer, center=(self.vernier_left_center[0], self.vernier_left_center[1] + 4.0 * self.vernier_period), box_size=(self.vernier_length, self.vernier_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0], self.vernier_left_center[1] - self.vernier_period), box_size=(self.vernier_length, self.vernier_width)) elems += i3.Rectangle(layer=self.layer, center=(self.vernier_left_center[0], self.vernier_left_center[1] - 2.0 * self.vernier_period), box_size=(self.vernier_length, self.vernier_width)) elems += i3.Rectangle(layer=self.layer, center=(self.vernier_left_center[0], self.vernier_left_center[1] - 3.0 * self.vernier_period), box_size=(self.vernier_length, self.vernier_width)) elems += i3.Rectangle(layer=self.layer, center=(self.vernier_left_center[0], self.vernier_left_center[1] - 4.0 * self.vernier_period), box_size=(self.vernier_length, self.vernier_width)) # Add rectangles top VERNIER elems += i3.Rectangle(layer=self.layer, center=(self.vernier_top_center[0], self.vernier_top_center[1]), box_size=(self.vernier_width, self.vernier_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] + self.vernier_period, self.vernier_top_center[1]), box_size=(self.vernier_width, self.vernier_length)) elems += i3.Rectangle(layer=self.layer, center=(self.vernier_top_center[0] + 2.0 * self.vernier_period, self.vernier_top_center[1]), box_size=(self.vernier_width, self.vernier_length)) elems += i3.Rectangle(layer=self.layer, center=(self.vernier_top_center[0] + 3.0 * self.vernier_period, self.vernier_top_center[1]), box_size=(self.vernier_width, self.vernier_length)) elems += i3.Rectangle(layer=self.layer, center=(self.vernier_top_center[0] + 4.0 * self.vernier_period, self.vernier_top_center[1]), box_size=(self.vernier_width, self.vernier_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] - self.vernier_period, self.vernier_top_center[1]), box_size=(self.vernier_width, self.vernier_length)) elems += i3.Rectangle(layer=self.layer, center=(self.vernier_top_center[0] - 2.0 * self.vernier_period, self.vernier_top_center[1]), box_size=(self.vernier_width, self.vernier_length)) elems += i3.Rectangle(layer=self.layer, center=(self.vernier_top_center[0] - 3.0 * self.vernier_period, self.vernier_top_center[1]), box_size=(self.vernier_width, self.vernier_length)) elems += i3.Rectangle(layer=self.layer, center=(self.vernier_top_center[0] - 4.0 * self.vernier_period, self.vernier_top_center[1]), box_size=(self.vernier_width, self.vernier_length)) # Add TEXT elems += i3.PolygonText(layer=self.layer, coordinate=(x0, y0 - 100.0), text=self.layer_text, height=35.0) elif (self.complement == True and self.protection == False): # Add squares elems += i3.Rectangle( layer=self.layer, center=(x0 - 0.25 * self.cross_length - 0.5 * shift, y0 + 0.25 * self.cross_length + 0.5 * shift), box_size=(square_length, square_length)) elems += i3.Rectangle( layer=self.layer, center=(x0 + 0.25 * self.cross_length + 0.5 * shift, y0 + 0.25 * self.cross_length + 0.5 * shift), box_size=(square_length, square_length)) elems += i3.Rectangle( layer=self.layer, center=(x0 - 0.25 * self.cross_length - 0.5 * shift, y0 - 0.25 * self.cross_length - 0.5 * shift), box_size=(square_length, square_length)) elems += i3.Rectangle( layer=self.layer, center=(x0 + 0.25 * self.cross_length + 0.5 * shift, y0 - 0.25 * self.cross_length - 0.5 * shift), box_size=(square_length, square_length)) # Add rectangles left VERNIER elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] - self.vernier_complement_shift - 0.5 * self.vernier_complement_long_length, self.vernier_left_center[1]), box_size=(self.vernier_complement_long_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] + self.vernier_complement_shift + 0.5 * self.vernier_complement_long_length, self.vernier_left_center[1]), box_size=(self.vernier_complement_long_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length, self.vernier_left_center[1] + self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length, self.vernier_left_center[1] + self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length, self.vernier_left_center[1] + 2.0 * self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length, self.vernier_left_center[1] + 2.0 * self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length, self.vernier_left_center[1] + 3.0 * self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length, self.vernier_left_center[1] + 3.0 * self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length, self.vernier_left_center[1] + 4.0 * self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length, self.vernier_left_center[1] + 4.0 * self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length, self.vernier_left_center[1] - self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length, self.vernier_left_center[1] - self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length, self.vernier_left_center[1] - 2.0 * self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length, self.vernier_left_center[1] - 2.0 * self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length, self.vernier_left_center[1] - 3.0 * self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length, self.vernier_left_center[1] - 3.0 * self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length, self.vernier_left_center[1] - 4.0 * self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_left_center[0] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length, self.vernier_left_center[1] - 4.0 * self.vernier_complement_period), box_size=(self.vernier_complement_length, self.vernier_complement_width)) # Add rectangles top VERNIER elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0], self.vernier_top_center[1] - self.vernier_complement_shift - 0.5 * self.vernier_complement_long_length), box_size=(self.vernier_complement_width, self.vernier_complement_long_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0], self.vernier_top_center[1] + self.vernier_complement_shift + 0.5 * self.vernier_complement_long_length), box_size=(self.vernier_complement_width, self.vernier_complement_long_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] + self.vernier_complement_period, self.vernier_top_center[1] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] + self.vernier_complement_period, self.vernier_top_center[1] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] + 2.0 * self.vernier_complement_period, self.vernier_top_center[1] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] + 2.0 * self.vernier_complement_period, self.vernier_top_center[1] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] + 3.0 * self.vernier_complement_period, self.vernier_top_center[1] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] + 3.0 * self.vernier_complement_period, self.vernier_top_center[1] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] + 4.0 * self.vernier_complement_period, self.vernier_top_center[1] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] + 4.0 * self.vernier_complement_period, self.vernier_top_center[1] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] - self.vernier_complement_period, self.vernier_top_center[1] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] - self.vernier_complement_period, self.vernier_top_center[1] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] - 2.0 * self.vernier_complement_period, self.vernier_top_center[1] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] - 2.0 * self.vernier_complement_period, self.vernier_top_center[1] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] - 3.0 * self.vernier_complement_period, self.vernier_top_center[1] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] - 3.0 * self.vernier_complement_period, self.vernier_top_center[1] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] - 4.0 * self.vernier_complement_period, self.vernier_top_center[1] - self.vernier_complement_shift - 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) elems += i3.Rectangle( layer=self.layer, center=(self.vernier_top_center[0] - 4.0 * self.vernier_complement_period, self.vernier_top_center[1] + self.vernier_complement_shift + 0.5 * self.vernier_complement_length), box_size=(self.vernier_complement_width, self.vernier_complement_length)) else: elems += i3.Rectangle(layer=self.layer, center=(x0 - 43.5, y0 + 11.5), box_size=(self.protection_length, self.protection_width)) return elems
class AL_NP(i3.PCell): _name_prefix = "AL_NP" # Center of the structure position = i3.Coord2Property(default=(0.0, 0.0)) # Layer layer = i3.LayerProperty(default=i3.TECH.PPLAYER.CONTACT.PILLAR) layer_bool = i3.LayerProperty(default=i3.TECH.PPLAYER.NONE.DOC) # Mesa parameters offset = i3.PositiveNumberProperty(default=20) # width = i3.PositiveNumberProperty(default=79) # pillar = i3.BoolProperty(default=False) reservoir = i3.BoolProperty(default=False) class Layout(i3.LayoutView): def _generate_elements(self, elems): # Center of the structure (x0, y0) = self.position # width2 = 338 + 15 + 15 elems += i3.Rectangle(layer=self.layer, center=(8750 - 15 - 10 + 5, 1500), box_size=(500 - 40, 1800 - 100)) elems += i3.Rectangle(layer=self.layer, center=(10500 - 15 - 10, 1500), box_size=(3000 + 50, 145)) elems += i3.Rectangle(layer=self.layer, center=(8750 - 15 - 10 + 5 + 2420 - 150, 1000 - 120), box_size=(2000, 500 - 40)) #extra pad elems += i3.Rectangle( layer=self.layer_bool, center=(8750 - 15 - 10 + 5 + 2420 - 150 + 998, 1000 - 120 + 620), box_size=(4, 145)) #extra shrink on the interface for i in range(4): elems += i3.Rectangle(layer=self.layer, center=(10000 - 725 - i * 750 + 2000 + 350 + self.offset, 1316 + 72.75), box_size=(145, 77.5)) elems += i3.Rectangle( layer=self.layer, center=(10000 - 725 - i * 750 + 2000 + 350 + self.offset, 1684 - 72.75), # change box_size=(145, 77.5)) # Avoid solder spill on facet elems += i3.Rectangle(layer=self.layer_bool, center=(12000 - 20, 1500), box_size=(40, 50)) elems += i3.Rectangle(layer=self.layer_bool, center=(12000 - 750 * 2, 1500), box_size=(80, 50)) elems += i3.Rectangle(layer=self.layer_bool, center=(12000 - 750 * 3, 1500), box_size=(80, 50)) elems += i3.Rectangle(layer=self.layer_bool, center=(12000 - 750 * 4, 1500), box_size=(80, 50)) # reservoir if self.reservoir: for i in range(3): elems += i3.Rectangle(layer=self.layer, center=(-750 * i + 12000 - 750, 1572.5 + 20), box_size=(149, 40)) elems += i3.Rectangle(layer=self.layer, center=(-750 * i + 12000 - 750, 1427.5 - 20), box_size=(149, 40)) elems += i3.Rectangle(layer=self.layer, center=(-750 * i + 12000 - 750, 1572.5 + 20), box_size=(149, 40)) elems += i3.Rectangle(layer=self.layer, center=(-750 * i + 12000 - 750, 1427.5 - 20), box_size=(149, 40)) elems += i3.Rectangle(layer=self.layer, center=(-750 * i + 12000 - 750, 1572.5 + 20), box_size=(149, 40)) elems += i3.Rectangle(layer=self.layer, center=(-750 * i + 12000 - 750, 1427.5 - 20), box_size=(149, 40)) elems += i3.PolygonText( layer=self.layer, text="RE", coordinate=(12000, 2600), # alignment=(i3.TEXT_ALIGN_LEFT, i3.TEXT_ALIGN_LEFT), font=2, height=400.0) # Markers bigsquare = 16.5 smallsquare = 11.5 for i in range(-3, 0, 2): elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 78, 1568.75), box_size=(9, 9.5)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 49.5, 1572 - 32), box_size=(9, 9)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 49.5 - 57, 1572 - 32), box_size=(9, 9)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 78, 1568.75 - 57.5), box_size=(9, 9.5)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 58.75, 1572.5 - 13.25), box_size=(smallsquare, smallsquare)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 38.5, 1572.5 - 13.25), box_size=(smallsquare, smallsquare)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 58.75, 1572.5 - 13.25 - 38.5), box_size=(smallsquare, smallsquare)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 38.5, 1572.5 - 13.25 - 38.5), box_size=(smallsquare, smallsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 78, 1568.75-80), box_size=(7, 7.5)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 49.5, 1572 - 32-80), box_size=(7, 7)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 49.5 - 57, 1572 - 32-80), box_size=(7, 7)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 78, 1568.75 - 57.5-80), box_size=(7, 7.5)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75-2.5, 1572.5 - 13.25-80-2.5), box_size=(bigsquare, bigsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75 - 38.5+2.5, 1572.5 - 13.25-80-2.5), # box_size=(bigsquare, bigsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75-2.5, 1572.5 - 13.25 - 38.5-80+2.5), # box_size=(bigsquare, bigsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75 - 38.5+2.5, 1572.5 - 13.25 - 38.5-80+2.5), # box_size=(bigsquare, bigsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 78-594, 1568.75), box_size=(7, 7.5)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 49.5-594, 1572 - 32), box_size=(7, 7)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 49.5 - 57-594, 1572 - 32), box_size=(7, 7)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 78-594, 1568.75 - 57.5), box_size=(7, 7.5)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75-594-2.5, 1572.5 - 13.25-2.5), box_size=(bigsquare, bigsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75 - 38.5-594+2.5, 1572.5 - 13.25-2.5), # box_size=(bigsquare, bigsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75-594-2.5, 1572.5 - 13.25 - 38.5+2.5), # box_size=(bigsquare, bigsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75 - 38.5-594+2.5, 1572.5 - 13.25 - 38.5+2.5), # box_size=(bigsquare, bigsquare)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 78 - 594, 1568.75 - 80), box_size=(9, 9.5)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 49.5 - 594, 1572 - 32 - 80), box_size=(9, 9)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 49.5 - 57 - 594, 1572 - 32 - 80), box_size=(9, 9)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 78 - 594, 1568.75 - 57.5 - 80), box_size=(9, 9.5)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 594, 1572.5 - 13.25 - 80), box_size=(smallsquare, smallsquare)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 38.5 - 594, 1572.5 - 13.25 - 80), box_size=(smallsquare, smallsquare)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 594, 1572.5 - 13.25 - 38.5 - 80), box_size=(smallsquare, smallsquare)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 38.5 - 594, 1572.5 - 13.25 - 38.5 - 80), box_size=(smallsquare, smallsquare)) for i in range(-2, 1, 2): # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 78, 1568.75), box_size=(7, 7.5)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 49.5, 1572-32), box_size=(7, 7)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 49.5-57, 1572-32), box_size=(7, 7)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 78, 1568.75-57.5), box_size=(7, 7.5)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75, 1572.5-13.25), box_size=(smallsquare, smallsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75-38.5, 1572.5 - 13.25), box_size=(smallsquare, smallsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75, 1572.5 - 13.25-38.5), box_size=(smallsquare, smallsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75-38.5, 1572.5 - 13.25-38.5), box_size=(smallsquare, smallsquare)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 78, 1568.75 - 80), box_size=(9, 9.5)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 49.5, 1572 - 32 - 80), box_size=(9, 9)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 49.5 - 57, 1572 - 32 - 80), box_size=(9, 9)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 78, 1568.75 - 57.5 - 80), box_size=(9, 9.5)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 2.5, 1572.5 - 13.25 - 80 - 2.5), box_size=(bigsquare, bigsquare)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 38.5 + 2.5, 1572.5 - 13.25 - 80 - 2.5), box_size=(bigsquare, bigsquare)) elems += i3.Rectangle( layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 2.5, 1572.5 - 13.25 - 38.5 - 80 + 2.5), box_size=(bigsquare, bigsquare)) elems += i3.Rectangle( layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 38.5 + 2.5, 1572.5 - 13.25 - 38.5 - 80 + 2.5), box_size=(bigsquare, bigsquare)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 78 - 594, 1568.75), box_size=(9, 9.5)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 49.5 - 594, 1572 - 32), box_size=(9, 9)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 49.5 - 57 - 594, 1572 - 32), box_size=(9, 9)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 78 - 594, 1568.75 - 57.5), box_size=(9, 9.5)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 594 - 2.5, 1572.5 - 13.25 - 2.5), box_size=(bigsquare, bigsquare)) elems += i3.Rectangle(layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 38.5 - 594 + 2.5, 1572.5 - 13.25 - 2.5), box_size=(bigsquare, bigsquare)) elems += i3.Rectangle( layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 594 - 2.5, 1572.5 - 13.25 - 38.5 + 2.5), box_size=(bigsquare, bigsquare)) elems += i3.Rectangle( layer=self.layer_bool, center=(750 * i + 12000 - 58.75 - 38.5 - 594 + 2.5, 1572.5 - 13.25 - 38.5 + 2.5), box_size=(bigsquare, bigsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 78-594, 1568.75 - 80), box_size=(7, 7.5)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 49.5-594, 1572 - 32 - 80), box_size=(7, 7)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 49.5 - 57-594, 1572 - 32 - 80), box_size=(7, 7)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 78-594, 1568.75 - 57.5 - 80), box_size=(7, 7.5)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75 -594, 1572.5 - 13.25 - 80 ), # box_size=(smallsquare, smallsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75 - 38.5 -594, 1572.5 - 13.25 - 80 ), # box_size=(smallsquare, smallsquare)) # elems += i3.Rectangle(layer=self.layer_bool, center=(750*i+12000 - 58.75 -594, 1572.5 - 13.25 - 38.5 - 80 ), # box_size=(smallsquare, smallsquare)) # elems += i3.Rectangle(layer=self.layer_bool, # center=(750*i+12000 - 58.75 - 38.5 -594, 1572.5 - 13.25 - 38.5 - 80 ), # box_size=(smallsquare, smallsquare)) generated1 = self.layer - self.layer_bool mapping = {generated1: self.layer} elems = i3.get_elements_for_generated_layers(elems, mapping) return elems