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
