def test_elem_cell():
c1 = spira.Cell(name='CellA')
assert c1.name == 'CellA'
assert len(c1.ports) == 0
assert len(c1.elementals) == 0
c1.ports += spira.Port(name='P1')
assert len(c1.ports) == 1
c1.elementals += spira.Polygons(shape=[[[0, 0], [1, 0], [1, 1], [0, 1]]])
assert len(c1.elementals) == 1
c1.center = (0, 0)
np.testing.assert_array_equal(c1.center, [0, 0])
c1.move(midpoint=c1.center, destination=(5, 0))
np.testing.assert_array_equal(c1.center, [5, 0])
class CellB(spira.Cell):
def create_elementals(self, elems):
elems += spira.Polygons(shape=[[[0, 0], [3, 0], [3, 1], [0, 1]]],
gdslayer=spira.Layer(number=77))
return elems
c2 = CellB()
assert c2.name == 'CellB-0'
assert len(c1.elementals) == 1
assert isinstance(c2.elementals[0], spira.Polygons)
def create_quadrant_three(self):
self.b1.connect(port=self.b1.ports['P2'],
destination=self.term_ports['T1'])
# h = self.p2[1] + (self.p1[1]-self.p2[1])/2 + self.radius
h = (self.p1[1] - self.p2[1]) / 2 + self.radius
self.b1.move(midpoint=self.b1.ports['P2'], destination=[0, h])
self.b2.connect(port=self.b2.ports['P2'],
destination=self.b1.ports['P1'])
# h = self.p2[1] + (self.p1[1]-self.p2[1])/2 - self.radius
h = (self.p1[1] - self.p2[1]) / 2 - self.radius
self.b2.move(midpoint=self.b2.ports['P1'],
destination=[self.term_ports['T2'].midpoint[0], h])
r1 = self._generate_route(self.b2.ports['P1'], self.term_ports['T2'])
r2 = self._generate_route(self.b1.ports['P2'], self.term_ports['T1'])
r3 = self._generate_route(self.b2.ports['P2'], self.b1.ports['P1'])
D = spira.Cell(name='Q3')
D += [self.b1, self.b2, r1, r2, r3]
D += self.term_ports['T1']
D += self.term_ports['T2']
D.rotate(angle=self.port1.orientation, center=self.p1)
D.move(midpoint=self.term_ports['T1'], destination=self.port1)
return spira.SRef(D)
def create_q4_180(self):
b1 = self.b1
b2 = self.b2
b2.connect(port=b2.ports['P1'], destination=self.term_ports['T1'])
h = self.p1[1] + self.radius + self.length
b2.move(midpoint=b2.ports['P1'], destination=[0, h])
b1.connect(port=b1.ports['P2'], destination=b2.ports['P2'])
b1.move(midpoint=b1.ports['P1'],
destination=[self.term_ports['T2'].midpoint[0], h])
r1 = self._generate_route(b2.ports['P1'], self.term_ports['T1'])
r2 = self._generate_route(b1.ports['P1'], self.term_ports['T2'])
r3 = self._generate_route(b1.ports['P2'], b2.ports['P2'])
D = spira.Cell(name='SameQ4')
D += [self.b1, self.b2, r1, r2, r3]
D += self.term_ports['T1']
D += self.term_ports['T2']
D.rotate(angle=self.port1.orientation, center=self.p1)
D.move(midpoint=self.term_ports['T1'], destination=self.port1)
return spira.SRef(D)
def create_spira_cell(cell):
# TODO: Detect cell type before assignment.
if cell.name.startswith('jj'):
D = spira.Junction(name=cell.name)
elif cell.name.startswith('via'):
D = spira.Via(name=cell.name)
else:
D = spira.Cell(name=cell.name)
return D
def test_cell_list():
cl = spira.CellList()
assert cl.is_empty() == True
c1 = spira.Cell('C1')
c2 = spira.Cell('C2')
c3 = spira.Cell('C3')
cl += c1
cl += [c2, c3]
assert len(cl) == 3
assert cl['C2'] == c2
assert cl.index('C2') == 1
assert cl.index(c2) == 1
del cl['C1']
assert cl[0] == c2
assert len(cl) == 2
del cl[c3]
assert len(cl) == 1
def test_library():
l1 = spira.Library()
l2 = spira.Library(name='library')
l3 = spira.Library()
assert l1.is_empty() == True
cell = spira.Cell(name='C1')
l1 += cell
l3 += cell
assert l1 == l3
assert l1 != l2
assert len(l1) == 1
assert l1.name == 'spira_library'
assert l2.name == 'library'
assert (cell in l1) == True
assert l1['C1'] == cell
l1.clear()
assert len(l1) == 0
assert l1 == l2
xc = self.rho * np.cos(theta)
yc = self.rho * np.sin(theta)
arm_x_left = self.arm_lengths[0] * np.sin(theta)
arm_y_left = self.arm_lengths[0] * np.cos(theta)
arm_x_right = self.arm_lengths[1] * np.sin(theta)
arm_y_right = self.arm_lengths[1] * np.cos(theta)
xpts = semicircle_x.tolist() + [
xc + arm_x_right, xc + arm_x_right + self.arm_widths[1],
xc + self.arm_widths[1], xc + self.arm_widths[1], 0,
-(xc + self.arm_widths[0]), -(xc + self.arm_widths[0]),
-(xc + arm_x_left + self.arm_widths[0]), -(xc + arm_x_left)
]
ypts = semicircle_y.tolist() + [
yc + arm_y_right, yc + arm_y_right, yc, yc - self.source_length,
yc - self.source_length, yc - self.source_length, yc,
yc + arm_y_left, yc + arm_y_left
]
points = np.array([list(zip(xpts, ypts))])
return points
if __name__ == "__main__":
ytron = YtronShape()
cell = spira.Cell(name='yTron')
cell += spira.Polygons(shape=ytron)
cell.output()
ports += spira.Term(name='T1',
midpoint=self.jj1.ports['Input'] + [10, 0],
orientation=-90)
ports += spira.Term(name='T2',
midpoint=self.jj2.ports['Output'] + [-10, 0],
orientation=90)
return ports
if __name__ == '__main__':
name = 'JTL PCell'
spira.LOG.header('Running example: {}'.format(name))
jtl = spira.Cell(name='JTL')
# jj_q1 = Jtl(m2=(30,30), rotation=0)
# jj_q2 = Jtl(m2=(-30,30), rotation=0)
# jj_q3 = Jtl(m2=(-30,-30), rotation=0)
jj_q4 = Jtl(m2=(30, -30), rotation=0)
# jtl += spira.SRef(jj_q1, midpoint=(0,0))
# jtl += spira.SRef(jj_q2, midpoint=(100,0))
# jtl += spira.SRef(jj_q3, midpoint=(100,0))
jtl += spira.SRef(jj_q4, midpoint=(100, 0))
jtl.output(name=name)
spira.LOG.end_print('JTL example finished')
s3 = spira.SRef(r1)
elems += s3
s4 = spira.SRef(r2)
elems += s4
elems += [s1, s2]
return elems
if __name__ == '__main__':
name = 'SQUID PCell'
spira.LOG.header('Running example: {}'.format(name))
squid = spira.Cell(name='SQUID')
# s5 = Squid(m2=(30,30), rotation=0)
# s6 = Squid(m2=(-30,30), rotation=0)
s7 = Squid(m2=(30, -30), rotation=0)
# squid += spira.SRef(s5, midpoint=(0,0))
# squid += spira.SRef(s6, midpoint=(50,0))
squid += spira.SRef(s7, midpoint=(100, 0))
squid.output(name=name)
spira.LOG.end_print('SQUID example finished')
def import_gds(filename, cellname=None, flatten=False, duplayer={}):
""" """
LOG.header('Imported GDS file -> \'{}\''.format(filename))
gdsii_lib = gdspy.GdsLibrary(name='SPiRA-Cell')
gdsii_lib.read_gds(filename)
top_level_cells = gdsii_lib.top_level()
if cellname is not None:
if cellname not in gdsii_lib.cell_dict:
raise ValueError("[SPiRA] import_gds() The requested cell " +
"(named {}) is not present in file {}".format(
cellname, filename))
topcell = gdsii_lib.cell_dict[cellname]
elif cellname is None and len(top_level_cells) == 1:
topcell = top_level_cells[0]
elif cellname is None and len(top_level_cells) > 1:
# TODO: Add this to logger.
print('Multiple toplevel cells found:')
for cell in top_level_cells:
print(cell)
raise ValueError('[SPiRA] import_gds() There are multiple' +
'top-level cells, you must specify cellname' +
'to select of one of them')
cell_list = spira.ElementList()
c2dmap = {}
for cell in gdsii_lib.cell_dict.values():
D = create_spira_cell(cell)
for e in cell.elements:
if isinstance(e, gdspy.PolygonSet):
for points in e.polygons:
layer = spira.Layer(number=e.layers[0],
datatype=e.datatypes[0])
ply = spira.Polygons(shape=spd([points]), gdslayer=layer)
D += ply
elif isinstance(e, gdspy.Polygon):
layer = spira.Layer(number=e.layers, datatype=e.datatype)
ply = spira.Polygons(shape=spd([e.points]), gdslayer=layer)
D += ply
c2dmap.update({cell: D})
cell_list += cell
for cell in cell_list:
wrap_references(cell, c2dmap)
wrap_labels(cell, c2dmap)
top_spira_cell = c2dmap[topcell]
# print('Toplevel Cell: {}\n'.format(top_spira_cell))
# print('\n---------- Cells --------------')
# for i, D in enumerate(top_spira_cell.dependencies()):
# print('{}. {}'.format(i, D.name))
# print('')
if flatten == True:
D = spira.Cell(name='import_gds')
# for key, polygon in top_spira_cell.get_polygons(True).items():
# layer, datatype = key[0], key[1]
# for l1, l2 in duplayer.items():
# if layer == l1: layer = l2
# poly = spira.Polygons(polygons=polygon, gdslayer=layer, gdsdatatype=datatype)
# poly.scale_up()
# D += poly
# for l in top_spira_cell.lbls:
# params = {}
# params['text'] = l.text
# params['gdslayer'] = l.gdslayer
# params['str_anchor'] = l.str_anchor
# D += spira.Label(position=scu(l.position), **params)
return D
else:
return top_spira_cell
points.extend(box.points)
return points
if __name__ == '__main__':
circle_shape = CircleShape()
hexagon_shape = ConvexPolygon()
arrow_shape = ArrowShape()
arrow_shape.apply_merge
rect_shape = RectangleShape()
box_shape = BoxShape()
basic_tri_shape = BasicTriangle()
tri_shape = TriangleShape()
tri_shape.apply_merge
cell = spira.Cell(name='Basic Shapes')
circle = spira.Polygons(shape=circle_shape,
gdslayer=spira.Layer(number=13))
circle.center = (0, 0)
hexagon = spira.Polygons(shape=hexagon_shape,
gdslayer=spira.Layer(number=14))
hexagon.center = (5, 0)
arrow = spira.Polygons(shape=arrow_shape, gdslayer=spira.Layer(number=15))
arrow.center = (10, 0)
rect = spira.Polygons(shape=rect_shape, gdslayer=spira.Layer(number=16))
rect.center = (15, 0)
box = spira.Polygons(shape=box_shape, gdslayer=spira.Layer(number=17))
box.center = (20, 0)
basic = spira.Polygons(shape=basic_tri_shape,
gdslayer=spira.Layer(number=18))
