def define_elements(self, elems):
# draw tip
## Warning: end-waveguide definition is calculated using y_spacing and tip_width, only wg-width is extracted from wg_def
wg_def_stop = WgElDefinition(wg_width = self.wg_def_end.wg_width, trench_width = 0.5*(self.y_spacing-self.wg_def_end.wg_width)-1.0)
elems += WgElTaperLinear(start_position = (self.tip_length + self.tip_offset, 0.0),
end_position = (self.tip_offset, 0.0),
start_wg_def = self.wg_def_start,
end_wg_def = wg_def_stop)
if self.extension > 0:
wg_def = WgElDefinition(wg_width = self.wg_def_end.wg_width, trench_width = 0.5*(self.y_spacing-self.wg_def_end.wg_width)-1.0, process = self.process)
elems += wg_def([(self.tip_offset - self.extension , 0.0), (self.tip_offset, 0.0)])
#assist lines for tip
for i in range(self.assist_lines):
elems += Path(PPLayer(self.process, TECH.PURPOSE.LF.LINE),
[(self.tip_length + self.tip_offset, 0.0 + (0.5*self.tip_start_width + (i+1)*(self.assist_width+ self.assist_spacing) - 0.5*self.assist_width)),
(self.tip_offset, 0.0 + (0.5*self.tip_width + (i+1)*(self.assist_width+ self.assist_spacing) - 0.5*self.assist_width)),
(self.tip_offset - self.extension, 0.0 + (0.5*self.tip_width + (i+1)*(self.assist_width+ self.assist_spacing) - 0.5*self.assist_width)),
], self.assist_width)
elems += Path(PPLayer(self.process, TECH.PURPOSE.LF.LINE),
[(self.tip_length + self.tip_offset, 0.0 - (0.5*self.tip_start_width+ (i+1)*(self.assist_width+ self.assist_spacing) - 0.5*self.assist_width)),
(self.tip_offset, 0.0 - (0.5*self.tip_width + (i+1)*(self.assist_width+ self.assist_spacing) - 0.5*self.assist_width)),
(self.tip_offset- self.extension, 0.0 - (0.5*self.tip_width + (i+1)*(self.assist_width+ self.assist_spacing) - 0.5*self.assist_width)),
], self.assist_width)
return elems
def define_elements(self, elems):
elems = ElementList()
if self.overlay_process != TECH.PROCESS.NONE:
VI1 = VernierMarkVI(layer=PPLayer(self.overlay_process,
self.overlay_purpose),
marks_width=self.inner_marks_width,
marks_length=self.marks_length)
elems += ARefY(VI1,
(0.0, self.outer_pitch + self.outer_marks_width -
self.inner_marks_width), self.inner_pitch,
self.n_o_lines)
if self.master_process != TECH.PROCESS.NONE:
VO1 = VernierMarkVO(layer=PPLayer(self.master_process,
self.master_purpose),
marks_width=self.outer_marks_width,
marks_length=self.marks_length)
elems += ARefY(VO1, (0.0, self.outer_pitch), self.outer_pitch,
self.n_o_lines)
si = elems.size_info()
elems += Rectangle(layer=PPLayer(TECH.PROCESS.NONE,
TECH.PURPOSE.NO_FILL),
center=si.center,
box_size=(si.width + 2 * self.no_fill_clearing,
si.height + 2 * self.no_fill_clearing))
elems += Rectangle(layer=PPLayer(TECH.PROCESS.NONE,
TECH.PURPOSE.NO_FILL),
center=si.center,
box_size=(si.width + 2 * self.no_fill_clearing,
si.height + 2 * self.no_fill_clearing))
return elems
def initialize(self):
from ipkiss.process import PPLayer
from ipkiss.visualisation.display_style import DisplayStyle, DisplayStyleSet
from ipkiss.visualisation import color
self.PREDEFINED_STYLE_SETS = TechnologyTree()
# colorful purpose map
DISPLAY_BLACK = DisplayStyle(color=color.COLOR_BLACK, edgewidth=0.0)
DISPLAY_WHITE = DisplayStyle(color=color.COLOR_WHITE, edgewidth=0.0)
DISPLAY_INVERSION = DisplayStyle(color=color.COLOR_BLUE,
alpha=0.5,
edgewidth=1.0)
DISPLAY_DF = DisplayStyle(color=color.COLOR_GREEN,
alpha=0.5,
edgewidth=1.0)
DISPLAY_LF = DisplayStyle(color=color.COLOR_YELLOW,
alpha=0.5,
edgewidth=1.0)
DISPLAY_TEXT = DisplayStyle(color=color.COLOR_MAGENTA,
alpha=0.5,
edgewidth=1.0)
DISPLAY_HOLE = DisplayStyle(color=color.COLOR_RED,
alpha=0.5,
edgewidth=1.0)
DISPLAY_ALIGNMENT = DisplayStyle(color=color.COLOR_CYAN,
alpha=0.5,
edgewidth=1.0)
style_set = DisplayStyleSet()
style_set.background = DISPLAY_WHITE
process_display_order = [
TECH.PROCESS.RFC, TECH.PROCESS.FCW, TECH.PROCESS.FC,
TECH.PROCESS.WG, TECH.PROCESS.NT, TECH.PROCESS.EBW,
TECH.PROCESS.HFW, TECH.PROCESS.VGW, TECH.PROCESS.CO,
TECH.PROCESS.NBODY, TECH.PROCESS.PBODY, TECH.PROCESS.P1,
TECH.PROCESS.PPLUS, TECH.PROCESS.N1, TECH.PROCESS.NPLUS,
TECH.PROCESS.PP1, TECH.PROCESS.PP2, TECH.PROCESS.SAL,
TECH.PROCESS.MC1, TECH.PROCESS.MC2, TECH.PROCESS.MH,
TECH.PROCESS.M1, TECH.PROCESS.V12, TECH.PROCESS.M2,
TECH.PROCESS.MP1, TECH.PROCESS.MP2, TECH.PROCESS.FC2,
TECH.PROCESS.WG2, TECH.PROCESS.VO1, TECH.PROCESS.GW1,
TECH.PROCESS.GW2, TECH.PROCESS.GW3
]
for process in process_display_order:
style_set += [
(PPLayer(process, TECH.PURPOSE.LF_AREA), DISPLAY_INVERSION),
(PPLayer(process, TECH.PURPOSE.DF_AREA), DISPLAY_INVERSION),
(PPLayer(process, TECH.PURPOSE.DF.MARKER), DISPLAY_ALIGNMENT),
(PPLayer(process, TECH.PURPOSE.LF.MARKER), DISPLAY_ALIGNMENT),
(PPLayer(process, TECH.PURPOSE.LF.LINE), DISPLAY_DF),
(PPLayer(process, TECH.PURPOSE.LF.ISLAND), DISPLAY_DF),
(PPLayer(process, TECH.PURPOSE.DF.TEXT), DISPLAY_TEXT),
(PPLayer(process, TECH.PURPOSE.DF.HOLE), DISPLAY_HOLE),
(PPLayer(process, TECH.PURPOSE.DF.TRENCH), DISPLAY_LF),
(PPLayer(process, TECH.PURPOSE.DF.SQUARE), DISPLAY_HOLE),
]
self.PREDEFINED_STYLE_SETS.PURPOSE_HIGHLIGHT = style_set
def define_elements(self, elems):
# add shape elements and stuff that should only be on the waveguide layer
elems += Rectangle(PPLayer(self.process, TECH.PURPOSE.LF.LINE),
(0.0, 0.0), (self.width, self.height))
elems += Rectangle(PPLayer(self.process, TECH.PURPOSE.LF_AREA),
(0.0, 0.0), (self.width + 2 * self.trench_width,
self.height + 2 * self.trench_width))
return elems
def define_elements(self, elems):
elems += super(NitrideInvertedTaper,self).define_elements(elems)
# WG
elems += Line(PPLayer(self.process,TECH.PURPOSE.LF_AREA),
(0.0, 0.0), (self.nitride_only_length - self.extension , 0.0),
self.y_spacing)
# NT
elems += Line(PPLayer(self.nt_process, TECH.PURPOSE.LF.LINE),
(0.0, 0.0), (self.nitride_only_length + self.tip_length + 100.0 , 0.0),
self.nitride_width )
return elems
def define_elements(self, elems):
# WG
elems += Line(PPLayer(self.deep_process,TECH.PURPOSE.LF_AREA),
(0.0, 0.0), (self.nitride_only_length - self.extension , 0.0),
self.y_spacing)
# FC
s_o_length = self.tip_offset + self.tip_length
elems += Line(PPLayer(self.shallow_process, TECH.PURPOSE.LF_AREA),
(0.0, 0.0), (s_o_length- self.extension , 0.0),
self.y_spacing)
# NT
elems += Line(PPLayer(self.nt_process, TECH.PURPOSE.LF.LINE),
(0.0, 0.0), (self.nitride_only_length + self.tip_length + self.shallow_tip_length + 50.0 , 0.0),
self.nitride_width )
return elems
def define_unit_cell(self):
s = ShapeRectangle(center=(0.0, 0.0),
box_size=(self.hole_diameters[0],
self.hole_diameters[1]))
s.transform(Rotation(rotation=45.0))
return Structure(
self.name + "_hpr",
Boundary(PPLayer(self.process, TECH.PURPOSE.DF.SQUARE), s))
def GratingUniformLine(line_width,
line_length,
period,
n_o_periods,
purpose=TECH.PURPOSE.DF.TRENCH,
process=TECH.PROCESS.FC):
""" 1-D grating (X-direction) with uniform lines"""
unit_cell = Structure(
"line" + str(int(line_width * 1000)) + "_" +
str(int(line_length * 1000)) + "_" +
str(PPLayer(process, purpose)).replace(" ", "_").replace("-", "_"),
Rectangle(PPLayer(process, purpose), (-0.5 * line_width, 0.0),
(line_width, line_length)))
origin = (-0.5 * (n_o_periods - 1) * period, 0.0)
return GratingUniform(unit_cell=unit_cell,
origin=origin,
period=(period, 1.0),
n_o_periods=(n_o_periods, 1))
def define_elements(self, elems):
# FCW
sqrt2_2 = 0.5 * sqrt(2)
side = self.period * self.n_o_periods
my_shape = Shape([(0.0, side * sqrt2_2), (side * sqrt2_2, 0.0),
(0.0, -side * sqrt2_2), (-side * sqrt2_2, 0.0)])
elems += Boundary(PPLayer(self.process, TECH.PURPOSE.DF.TRENCH),
coordinates=my_shape)
return elems
def define_elements(self, elems):
layout = IoColumnGroup(y_spacing=25.0, south_east=(6000.0,0.0))
#we first create a regular waveguide element
wg_def = WgElDefinition(wg_width = TECH.WG.WIRE_WIDTH, trench_width = TECH.WG.TRENCH_WIDTH, process = TECH.PROCESS.WG)
wg = wg_def(shape = [(0.0,0.0), (500.0,0.0)])
#on top of it, we add a rectangle element with III-V
rectangle_III_V = Rectangle(PPLayer(MY_TECH.PROCESS.OL35_1, MY_TECH.PURPOSE.DEFAULT), center = (250.0, 0.0),box_size = (500.0, 20.0))
#assemble both elemeents in a structure
layout += Structure(name= "wg_with_III_V", elements = [wg, rectangle_III_V], ports = wg.ports)
elems += layout
return elems
def define_elements(self, elems):
# WG
wg_def_stop = WgElDefinition(wg_width = self.wg_def_end.wg_width,trench_width = self.wg_def_start.trench_width)
shallow_tip_width = self.wg_def_sh_end.wg_width
shallow_tip_start_width = self.wg_def_sh_start.wg_width
elems += WgElTaperLinear(start_position = (self.shallow_tip_length + self.tip_offset + self.tip_length, 0.0),
end_position = (self.tip_offset + self.tip_length, 0.0),
start_wg_def = self.wg_def_start,
end_wg_def = self.wg_def_end)
# FC
s_o_length = self.tip_offset + self.tip_length
# draw taper to tip
wg_def_sh_start = WgElDefinition(wg_width = self.wg_def_sh_start.wg_width+1.0, trench_width = self.wg_def_start.trench_width)
wg_def_sh_end = WgElDefinition(wg_width = self.wg_def_sh_end.wg_width, trench_width = 0.5*(self.y_spacing-self.wg_def_sh_end.wg_width)-1.0)
elems += WgElTaperLinear( start_position = (self.shallow_tip_length + s_o_length, 0.0),
end_position = (s_o_length, 0.0),
start_wg_def = wg_def_sh_start,
end_wg_def = wg_def_sh_end,
process = self.shallow_process)
if self.extension > 0:
wg_def = WgElDefinition(wg_width = self.shallow_tip_width, trench_width = 0.5*(self.y_spacing-shallow_tip_width)-1.0, process = self.shallow_process)
elems += wg_def([(s_o_length - self.extension , 0.0), (s_o_length, 0.0)])
#assist lines for tip
for i in range(self.assist_lines):
elems += Path(PPLayer(self.shallow_process, TECH.PURPOSE.LF.LINE),
[(self.shallow_tip_length + s_o_length, (0.5*shallow_tip_start_width +0.5 + (i+1)*(self.assist_width+ self.assist_spacing) - 0.5*self.assist_width)),
(s_o_length, + (0.5*shallow_tip_width + (i+1)*(self.assist_width+ self.assist_spacing) - 0.5*self.assist_width)),
(s_o_length- self.extension , + (0.5*shallow_tip_width + (i+1)*(self.assist_width+ self.assist_spacing) - 0.5*self.assist_width))
], self.assist_width)
elems += Path(PPLayer(self.shallow_process, TECH.PURPOSE.LF.LINE),
[(self.shallow_tip_length + s_o_length, - (0.5*shallow_tip_start_width+0.5+ (i+1)*(self.assist_width+ self.assist_spacing) - 0.5*self.assist_width)),
(s_o_length, - (0.5*shallow_tip_width + (i+1)*(self.assist_width+ self.assist_spacing) - 0.5*self.assist_width)),
(s_o_length- self.extension , - (0.5*shallow_tip_width + (i+1)*(self.assist_width+ self.assist_spacing) - 0.5*self.assist_width))
], self.assist_width)
return elems
def define_unit_cell(self):
stub = 0.08
s = Shape()
d0 = 0.5 * self.hole_diameters[0]
d1 = 0.5 * self.hole_diameters[1]
s += (-d0 + stub, d1)
s += (d0 - stub, d1)
s += (d0, d1 - stub)
s += (d0, -d1 + stub)
s += (d0 - stub, -d1)
s += (-d0 + stub, -d1)
s += (-d0, -d1 + stub)
s += (-d0, d1 - stub)
s.transform(Rotation(rotation=-45.0))
return Structure(
self.name + "_hpr",
Boundary(PPLayer(self.process, TECH.PURPOSE.DF.SQUARE), s))
MY_TECH.PROCESS = TechnologyTree()
MY_TECH.PROCESS.OL35_1 = ProcessLayer("Overlay With III-V etch 1", "OL35_1")
MY_TECH.PROCESS.OL35_2 = ProcessLayer("Overlay With III-V etch 2", "OL35_2")
MY_TECH.PROCESS.BCB_1 = ProcessLayer("Bcb etch1", "BCB_1")
MY_TECH.PROCESS.BCB_2 = ProcessLayer("Bcb etch2", "BCB_2")
MY_TECH.PROCESS.MET_1 = ProcessLayer("Metalization etch1", "MET_1")
MY_TECH.PROCESS.MET_2 = ProcessLayer("Metalization etch2", "MET_2")
MY_TECH.PROCESS.MET_3 = ProcessLayer("Metalization etch3", "MET_3")
MY_TECH.PROCESS.MET_4 = ProcessLayer("Metalization etch4", "MET_4")
MY_TECH.PURPOSE = TechnologyTree()
MY_TECH.PURPOSE.DEFAULT = PatternPurpose(name = "Default", extension = "00")
MY_OUTPUT_MAP = copy.deepcopy(TECH.GDSII.EXPORT_LAYER_MAP)
MY_OUTPUT_MAP.layer_map[PPLayer(process = MY_TECH.PROCESS.OL35_1, purpose = MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(number = 101, datatype = DT_LINE) # disk
MY_OUTPUT_MAP.layer_map[PPLayer(process = MY_TECH.PROCESS.OL35_2, purpose = MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(number = 102, datatype = DT_LINE) # island
MY_OUTPUT_MAP.layer_map[PPLayer(process = MY_TECH.PROCESS.BCB_1, purpose = MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(number = 104, datatype = DT_LINE) # botvia
MY_OUTPUT_MAP.layer_map[PPLayer(process = MY_TECH.PROCESS.BCB_2, purpose = MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(number = 105, datatype = DT_LINE) # topvia
MY_OUTPUT_MAP.layer_map[PPLayer(process = MY_TECH.PROCESS.MET_1, purpose = MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(number = 103, datatype = DT_LINE) # botcont
MY_OUTPUT_MAP.layer_map[PPLayer(process = MY_TECH.PROCESS.MET_2, purpose = MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(number = 106, datatype = DT_LINE) # topcont
MY_OUTPUT_MAP.layer_map[PPLayer(process = MY_TECH.PROCESS.MET_3, purpose = MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(number = 107, datatype = DT_LINE) # pads
MY_OUTPUT_MAP.layer_map[PPLayer(process = MY_TECH.PROCESS.MET_4, purpose = MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(number = 108, datatype = DT_LINE) # plating
class Layout(Structure):
def define_elements(self, elems):
layout = IoColumnGroup(y_spacing=25.0, south_east=(6000.0,0.0))
def define_elements(self, elems):
ww0 = self.wg_definitions[0].wg_width
ww1 = self.wg_definitions[1].wg_width
# path shape from center to OpticalPort
L_tr = ShapePath(original_shape=[(0.0, 0.0), self.p_tr],
path_width=ww0)
L_br = ShapePath(original_shape=[(0.0, 0.0), self.p_br],
path_width=ww0)
L_l = ShapePath(original_shape=[(0.0, 0.0), self.p_l], path_width=ww1)
# indices for positions in the path (start_east, end_east, ...)
i_sl = 0
i_el = 1
i_sr = 3
i_er = 2
sh_wg = (ShapeStub(original_shape=[
L_tr[i_er],
intersection(L_tr[i_sr], L_tr[i_er], L_br[i_sl], L_br[i_el]),
L_br[i_el]
],
stub_width=TECH.TECH.MINIMUM_LINE) +
ShapeStub(original_shape=[
L_br[i_er],
intersection(L_br[i_sr], L_br[i_er], L_tr[i_sr],
L_tr[i_er]), L_l[i_el].move_copy(
(self.wg_lengths[1], 0.0)), L_l[i_el]
],
stub_width=TECH.TECH.MINIMUM_LINE,
only_sharp_angles=True) +
ShapeStub(original_shape=[
L_l[i_er], L_l[i_er].move_copy((self.wg_lengths[1], 0.0)),
intersection(L_tr[i_el], L_tr[i_sl], L_br[i_el],
L_br[i_sl]), L_tr[i_el]
],
stub_width=TECH.TECH.MINIMUM_LINE))
sh_wg.close()
# path shape from center to OpticalPort
T_tr = ShapePath(original_shape=[(0.0, 0.0), self.p_tr],
path_width=ww0 +
2 * self.wg_definitions[0].trench_width)
T_br = ShapePath(original_shape=[(0.0, 0.0), self.p_br],
path_width=ww0 +
2 * self.wg_definitions[0].trench_width)
T_l = ShapePath(original_shape=[(0.0, 0.0), self.p_l],
path_width=ww1 +
2 * self.wg_definitions[0].trench_width)
sh_tr = Shape([
L_tr[i_er],
T_tr[i_er], T_br[i_el], L_br[i_el], L_br[i_er], T_br[i_er],
(0.0, T_br[i_er].y), T_l[i_el], L_l[i_el], L_l[i_er], T_l[i_er],
(0.0, T_tr[i_el].y), T_tr[i_el], L_tr[i_el]
])
sh_tr.close()
elems += Boundary(
PPLayer(self.wg_definitions[0].process, TECH.PURPOSE.LF.LINE),
sh_wg)
elems += Boundary(
PPLayer(self.wg_definitions[0].process, TECH.PURPOSE.LF_AREA),
sh_tr)
return elems
def define_elements(self, elems):
ww0 = self.wg_definitions[0].wg_width
ww1 = self.wg_definitions[1].wg_width
tw0 = self.wg_definitions[0].trench_width
tw1 = self.wg_definitions[1].trench_width
# OpticalPort corners
p_tr1 = self.p_tr.move_polar_copy(0.5 * ww0, 135 - self.dev_angles[0])
p_tr2 = self.p_tr.move_polar_copy(0.5 * ww0, -45 - self.dev_angles[0]),
p_br1 = self.p_br.move_polar_copy(0.5 * ww0, 45 + self.dev_angles[0])
p_br2 = self.p_br.move_polar_copy(0.5 * ww0,
-135 + self.dev_angles[0]),
p_tl1 = self.p_tl.move_polar_copy(0.5 * ww1, -135 + self.dev_angles[1])
p_tl2 = self.p_tl.move_polar_copy(0.5 * ww1, 45 + self.dev_angles[1]),
p_bl1 = self.p_bl.move_polar_copy(0.5 * ww1, -45 - self.dev_angles[1])
p_bl2 = self.p_bl.move_polar_copy(0.5 * ww1, 135 - self.dev_angles[1]),
# path shape from center to OpticalPort
L_tr = ShapePath(original_shape=[(0.0, 0.0), self.p_tr],
path_width=ww0)
L_br = ShapePath(original_shape=[(0.0, 0.0), self.p_br],
path_width=ww0)
L_tl = ShapePath(original_shape=[(0.0, 0.0), self.p_tl],
path_width=ww1)
L_bl = ShapePath(original_shape=[(0.0, 0.0), self.p_bl],
path_width=ww1)
# indices for positions in the path (start_east, end_east, ...)
i_sl = 0
i_el = 1
i_sr = 3
i_er = 2
sh_wg = (ShapeStub(original_shape=[
L_tr[i_er],
intersection(L_tr[i_sr], L_tr[i_er], L_br[i_sl], L_br[i_el]),
L_br[i_el]
],
stub_width=TECH.TECH.MINIMUM_LINE) +
ShapeStub(original_shape=[
L_br[i_er],
intersection(L_br[i_sr], L_br[i_er], L_bl[i_sl],
L_bl[i_el]), L_bl[i_el]
],
stub_width=TECH.TECH.MINIMUM_LINE) +
ShapeStub(original_shape=[
L_bl[i_er],
intersection(L_bl[i_sr], L_bl[i_er], L_tl[i_sl],
L_tl[i_el]), L_tl[i_el]
],
stub_width=TECH.TECH.MINIMUM_LINE) +
ShapeStub(original_shape=[
L_tl[i_er],
intersection(L_tl[i_sr], L_tl[i_er], L_tr[i_sl],
L_tr[i_el]), L_tr[i_el]
],
stub_width=TECH.TECH.MINIMUM_LINE))
sh_wg.close()
# path shape from center to OpticalPort
T_tr = ShapePath(original_shape=[(0.0, 0.0), self.p_tr],
path_width=ww0 + 2 * tw0)
T_br = ShapePath(original_shape=[(0.0, 0.0), self.p_br],
path_width=ww0 + 2 * tw0)
T_tl = ShapePath(original_shape=[(0.0, 0.0), self.p_tl],
path_width=ww1 + 2 * tw1)
T_bl = ShapePath(original_shape=[(0.0, 0.0), self.p_bl],
path_width=ww1 + 2 * tw1)
sh_tr = Shape([L_tr[i_er], T_tr[i_er], T_br[i_el], L_br[i_el]] +
[L_br[i_er], T_br[i_er], T_bl[i_el], L_bl[i_el]] +
[L_bl[i_er], T_bl[i_er], T_tl[i_el], L_tl[i_el]] +
[L_tl[i_er], T_tl[i_er], T_tr[i_el], L_tr[i_el]])
sh_tr.close()
from ipkiss.process import PPLayer
elems += Boundary(
PPLayer(self.wg_definitions[0].process, TECH.PURPOSE.LF.LINE),
sh_wg)
elems += Boundary(
PPLayer(self.wg_definitions[0].process, TECH.PURPOSE.LF_AREA),
sh_tr)
return elems
def _default_layer(self): layer=PPLayer(process=i3.TECH.PROCESS.WG,purpose=i3.TECH.PURPOSE.LF.LINE) return layer
style_set = DisplayStyleSet()
style_set.background = DISPLAY_WHITE
process_display_order = [
TECH.PROCESS.WG, TECH.PROCESS.FC, TECH.PROCESS.SKT, TECH.PROCESS.FCW,
TECH.PROCESS.PBODY, TECH.PROCESS.NBODY, TECH.PROCESS.P1, TECH.PROCESS.N1,
TECH.PROCESS.P2, TECH.PROCESS.N2, TECH.PROCESS.PPLUS, TECH.PROCESS.NPLUS,
TECH.PROCESS.SAL, TECH.PROCESS.PCON, TECH.PROCESS.M1, TECH.PROCESS.VIA12,
TECH.PROCESS.M2, TECH.PROCESS.PASS1, TECH.PROCESS.METPASS,
TECH.PROCESS.EXPO, TECH.PROCESS.LPASS, TECH.PROCESS.PASS2,
TECH.PROCESS.TRENCH, TECH.PROCESS.NONE
]
style_set += [
(PPLayer(TECH.PROCESS.WG, TECH.PURPOSE.CLADDING), DISPLAY_CYAN),
(PPLayer(TECH.PROCESS.WG, TECH.PURPOSE.CORE), DISPLAY_VIOLET),
(PPLayer(TECH.PROCESS.WG, TECH.PURPOSE.TRENCH), DISPLAY_COPPER),
(PPLayer(TECH.PROCESS.WG, TECH.PURPOSE.HOLE), DISPLAY_BLUE),
(PPLayer(TECH.PROCESS.WG, TECH.PURPOSE.TRACE), DISPLAY_RED),
(PPLayer(TECH.PROCESS.FC, TECH.PURPOSE.CLADDING), DISPLAY_YELLOW),
(PPLayer(TECH.PROCESS.FC, TECH.PURPOSE.CORE), DISPLAY_ORANGE),
(PPLayer(TECH.PROCESS.FC, TECH.PURPOSE.TRENCH), DISPLAY_SANGRIA),
(PPLayer(TECH.PROCESS.FC, TECH.PURPOSE.HOLE), DISPLAY_SANGRIA),
(PPLayer(TECH.PROCESS.FC, TECH.PURPOSE.TRACE), DISPLAY_RED),
(PPLayer(TECH.PROCESS.SKT, TECH.PURPOSE.CLADDING), DISPLAY_GREEN),
(PPLayer(TECH.PROCESS.SKT, TECH.PURPOSE.CORE), DISPLAY_DARKSEY_GREEN),
(PPLayer(TECH.PROCESS.SKT, TECH.PURPOSE.TRENCH), DISPLAY_DARKGREEN),
(PPLayer(TECH.PROCESS.SKT, TECH.PURPOSE.HOLE), DISPLAY_DARKGREEN_HDENSE),
(PPLayer(TECH.PROCESS.SKT, TECH.PURPOSE.TRACE), DISPLAY_RED),
(PPLayer(TECH.PROCESS.FCW, TECH.PURPOSE.CORE), DISPLAY_PURPLE),
def _default_layer(self):
return PPLayer(process=TECH.PROCESS.M1,
purpose=TECH.PURPOSE.DRAWING)
def define_unit_cell(self):
s = ShapeRectangle((0.0, 0.0),
(self.hole_diameter, self.hole_diameter))
return Structure(
self.name + "_hp",
Boundary(PPLayer(self.process, TECH.PURPOSE.DF.SQUARE), s))
MY_TECH.PROCESS = TechnologyTree()
MY_TECH.PROCESS.OL35_1 = ProcessLayer("Overlay With III-V etch 1", "OL35_1")
MY_TECH.PROCESS.OL35_2 = ProcessLayer("Overlay With III-V etch 2", "OL35_2")
MY_TECH.PROCESS.BCB_1 = ProcessLayer("Bcb etch1", "BCB_1")
MY_TECH.PROCESS.BCB_2 = ProcessLayer("Bcb etch2", "BCB_2")
MY_TECH.PROCESS.MET_1 = ProcessLayer("Metalization etch1", "MET_1")
MY_TECH.PROCESS.MET_2 = ProcessLayer("Metalization etch2", "MET_2")
MY_TECH.PROCESS.MET_3 = ProcessLayer("Metalization etch3", "MET_3")
MY_TECH.PROCESS.MET_4 = ProcessLayer("Metalization etch4", "MET_4")
MY_TECH.PURPOSE = TechnologyTree()
MY_TECH.PURPOSE.DEFAULT = PatternPurpose(name="Default", extension="00")
MY_OUTPUT_MAP = copy.deepcopy(TECH.GDSII.EXPORT_LAYER_MAP)
MY_OUTPUT_MAP.layer_map[PPLayer(process=MY_TECH.PROCESS.OL35_1,
purpose=MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(
number=101, datatype=DT_LINE) # disk
MY_OUTPUT_MAP.layer_map[PPLayer(process=MY_TECH.PROCESS.OL35_2,
purpose=MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(
number=102, datatype=DT_LINE) # island
MY_OUTPUT_MAP.layer_map[PPLayer(process=MY_TECH.PROCESS.BCB_1,
purpose=MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(
number=104, datatype=DT_LINE) # botvia
MY_OUTPUT_MAP.layer_map[PPLayer(process=MY_TECH.PROCESS.BCB_2,
purpose=MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(
number=105, datatype=DT_LINE) # topvia
MY_OUTPUT_MAP.layer_map[PPLayer(process=MY_TECH.PROCESS.MET_1,
purpose=MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(
number=103, datatype=DT_LINE) # botcont
MY_OUTPUT_MAP.layer_map[PPLayer(process=MY_TECH.PROCESS.MET_2,
purpose=MY_TECH.PURPOSE.DEFAULT)] = GdsiiLayer(
def _default_layer_c(self): layer=PPLayer(process=i3.TECH.PROCESS.SK,purpose=i3.TECH.PURPOSE.DF_AREA) return layer
