def create_elementals(self, elems):
jj = Junction()
jj.center = (0, 0)
s1 = spira.SRef(jj, midpoint=self.m1, rotation=self.rotation)
s2 = spira.SRef(jj, midpoint=self.m2, rotation=-self.rotation)
r1 = RouteManhattan(port1=s1.ports['Output'],
port2=s2.ports['Output'],
radius=1,
length=1)
r2 = RouteManhattan(port1=s1.ports['Input'],
port2=s2.ports['Input'],
radius=1,
length=1)
s3 = spira.SRef(r1)
elems += s3
s4 = spira.SRef(r2)
elems += s4
elems += [s1, s2]
return elems
def create_elementals(self, elems):
s1 = self.jj1
s2 = self.jj2
if self.quadrant in ['Q1', 'Q4']:
route = RouteManhattan(port1=s1.ports['Output'],
port2=s2.ports['Input'],
radius=3,
length=1,
gdslayer=RDD.COU.LAYER)
if self.quadrant in ['Q2', 'Q3']:
route = RouteManhattan(port1=s2.ports['Output'],
port2=s1.ports['Input'],
radius=3,
length=1,
gdslayer=RDD.COU.LAYER)
s3 = spira.SRef(route)
s3.move(midpoint=s3.ports['T1'], destination=route.port1)
r1 = Route(port1=self.term_ports['T1'],
port2=s1.ports['Input'],
player=RDD.PLAYER.COU)
elems += spira.SRef(r1)
r2 = Route(port1=self.term_ports['T2'],
port2=s2.ports['Output'],
player=RDD.PLAYER.COU)
elems += spira.SRef(r2)
elems += [s1, s2, s3]
return elems
def test_q1_parallel(self):
# p1 = spira.Term(name='P1', midpoint=(0,0), orientation=0, width=2)
# p2 = spira.Term(name='P2', midpoint=(50,50), orientation=0, width=2)
p1 = spira.Term(name='P1', midpoint=(0, 0), orientation=180, width=2)
p2 = spira.Term(name='P2', midpoint=(50, 50), orientation=180, width=2)
rm = RouteManhattan(port1=p1, port2=p2, radius=8)
return spira.SRef(rm, midpoint=(150, 0))
def create_elementals(self, elems):
self.angular_coverage = np.deg2rad(self.angular_coverage)
inc_rad = (self.radius**-1) / self.num_steps
angle_step = self.angular_coverage / self.num_steps
print('inc_rad: {}'.format(inc_rad))
print('angle_step: {}'.format(angle_step))
arcs = []
for x in range(self.num_steps):
A = Arc(shape=ArcRoute(radius=1 / ((x + 1) * inc_rad),
width=self.width,
theta=np.rad2deg(angle_step),
start_angle=x * np.rad2deg(angle_step),
angle_resolution=self.angle_resolution,
gdslayer=self.gdslayer))
a = spira.SRef(A)
elems += a
arcs.append(a)
if x > 0:
a.connect(port='P1', destination=prevPort)
prevPort = a.ports['P2']
self.port1 = arcs[0].ports['P1']
elems += self._regular_bend(prevPort)
return elems
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 get_subarc_routes(self):
D = SubArcSeries(gdslayer=self.gdslayer,
radius=self.radius,
width=self.width,
angular_coverage=self.angular_coverage,
num_steps=self.num_steps,
angle_resolution=self.angle_resolution,
start_angle=self.start_angle)
s1 = spira.SRef(D)
s2 = spira.SRef(D)
s2.reflect(p1=[0, 0], p2=[1, 1])
s2.connect(port='P2', destination=s1.ports['P2'])
return s1, s2
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 test_q3_90(self):
p1 = spira.Term(name='P1', midpoint=(0, 0), orientation=180, width=2)
p2 = spira.Term(name='P2',
midpoint=(-40, -20),
orientation=-90,
width=2)
rm = RouteManhattan(port1=p1, port2=p2, radius=8)
return spira.SRef(rm, midpoint=(-50, -50))
def test_q1_180(self):
p1 = spira.Term(name='P1', midpoint=(0, 0), orientation=0, width=2)
p2 = spira.Term(name='P2',
midpoint=(40, 20),
orientation=180,
width=1.5)
rm = RouteManhattan(port1=p1, port2=p2, radius=8)
return spira.SRef(rm, midpoint=(0, 50))
def create_mlayers(self):
elems = spira.ElementList()
# players = RDD.PLAYER.get_physical_layers(purpose_symbol=['METAL', 'GROUND', 'MOAT'])
flat_elems = self.cell_elems.flat_copy()
for pl in RDD.PLAYER.get_physical_layers(purposes='METAL'):
metal_elems = flat_elems.get_polygons(layer=pl.layer)
if metal_elems:
c_mlayer = CMLayers(layer=pl.layer)
for i, ply in enumerate(self._merge_layers(metal_elems)):
ml = MLayer(name='MLayer_{}_{}_{}_{}'.format(
pl.layer.number, self.cell.name, self.cell.id, i),
points=ply.polygons,
number=pl.layer.number)
c_mlayer += spira.SRef(ml)
elems += spira.SRef(c_mlayer)
return elems
def _generate_route(self, p1, p2):
route = RouteShape(port1=p1,
port2=p2,
path_type='straight',
width_type='straight')
R1 = RouteBasic(route=route, connect_layer=self.gdslayer)
r1 = spira.SRef(R1)
r1.rotate(angle=p2.orientation - 180, center=R1.port1.midpoint)
r1.move(midpoint=(0, 0), destination=p1.midpoint)
return r1
def create_arc_bend_2(self):
if self.bend_type == 'circular':
B2 = Arc(shape=ArcRoute(
radius=self.radius,
width=self.port1.width,
gdslayer=self.gdslayer,
# gdslayer=spira.Layer(number=18),
start_angle=0,
theta=-90))
return spira.SRef(B2)
def wrap_references(cell, c2dmap):
for e in cell.elements:
if isinstance(e, gdspy.CellReference):
D = c2dmap[cell]
ref_device = c2dmap[e.ref_cell]
D += spira.SRef(structure=ref_device,
midpoint=scd(e.midpoint),
rotation=e.rotation,
magnification=e.magnification,
reflection=e.x_reflection)
def create_elementals(self, elems):
jj = Junction()
# FIXME: Automate this movement.
jj.move(origin=jj.center, destination=(0, 0))
# FIXME: Rotation applies to parent cell.
j1 = spira.SRef(jj, origin=(-1, 0), rotation=90)
# j1.move(origin=j1.ref.center, destination=(0,0))
j2 = spira.SRef(jj, origin=(10.5, 0), rotation=180)
elems += j1
elems += j2
elems += self.top_routing
elems += self.bot_routing
return elems
def create_elementals(self, elems):
super().create_elementals(elems)
if self.level == 1:
if self.ground_layer:
box = self.cell.bbox
# box.move(midpoint=box.center, destination=(0,0))
gnd = self.ground_layer | box
if gnd:
c_glayer = CGLayers(layer=gnd.gdslayer)
name = 'GLayer_{}_{}'.format(self.cell.name,
gnd.gdslayer.number)
gnd_layer = GLayer(name=name,
layer=gnd.gdslayer,
player=gnd)
c_glayer += spira.SRef(gnd_layer)
elems += spira.SRef(c_glayer)
return elems
def test_elem_sref():
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()
s1 = spira.SRef(structure=c2)
assert all([a == b for a, b in zip(s1.midpoint, [0, 0])])
assert s1.rotation == 0
assert s1.magnification == 1
assert s1.reflection == False
def create_elementals(self, elems):
route = RouteShape(port1=self.port1,
port2=self.port2,
path_type='straight',
width_type='straight')
R1 = RouteBasic(route=route, connect_layer=self.player.layer)
r1 = spira.SRef(R1)
r1.rotate(angle=self.port2.orientation - 180, center=R1.port1.midpoint)
r1.move(midpoint=(0, 0), destination=self.port1.midpoint)
elems += r1
return elems
def create_nlayers(self):
elems = ElementList()
flat_elems = self.cell_elems.flat_copy()
for pl in RDD.PLAYER.get_physical_layers(purposes='VIA'):
via_elems = flat_elems.get_polygons(layer=pl.layer)
if via_elems:
c_nlayer = CNLayers(layer=pl.layer)
for i, ply in enumerate(via_elems):
ml = NLayer(name='Via_NLayer_{}_{}_{}'.format(
pl.layer.number, self.cell.name, i),
points=ply.polygons,
midpoint=ply.center,
number=pl.layer.number)
c_nlayer += spira.SRef(ml)
elems += SRef(c_nlayer)
return elems
def create_elementals(self, elems):
D = ArcSeries(gdslayer=self.gdslayer,
radius=self.radius,
width=self.width,
angular_coverage=self.angular_coverage,
num_steps=self.num_steps,
angle_resolution=self.angle_resolution,
start_angle=self.start_angle)
# D.xmin, D.ymin = 0, 0
# Orient to default settings...
# D.reflect(p1=[0,0], p2=[1,1])
# D.reflect(p1=[0,0], p2=[1,0])
# D.rotate(angle=self.start_angle, center=D.center)
# D.center = [0, 0]
s1 = spira.SRef(D)
elems += s1
return elems
def _regular_bend(self, prev_port):
""" Now connect a regular bend for
the normal curved portion. """
B = Arc(shape=ArcRoute(radius=self.radius,
width=self.width,
theta=45 - np.rad2deg(self.angular_coverage),
start_angle=self.angular_coverage,
angle_resolution=self.angle_resolution,
gdslayer=spira.Layer(number=88)))
b = spira.SRef(B)
b.connect(port='P1', destination=prev_port)
p0 = b.ports['P2']
self.port2 = spira.Term(
name='P2',
midpoint=p0.midpoint,
# midpoint=scu(p0.midpoint),
width=p0.width,
orientation=p0.orientation)
return b
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 create_junction_two(self):
jj = Junction()
jj.center = (0, 0)
return spira.SRef(jj, midpoint=self.m2, rotation=-self.rotation)
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')
def test_p1p2_180_horizontal(self):
p1 = spira.Term(name='P1', midpoint=(0, 0), orientation=0, width=2)
p2 = spira.Term(name='P2', midpoint=(40, 0), orientation=0, width=2)
rm = RouteManhattan(port1=p1, port2=p2, radius=8)
return spira.SRef(rm, midpoint=(150, 0))
def test_p2p1_180_vertical_bot(self):
p1 = spira.Term(name='P1', midpoint=(0, 0), orientation=-90, width=2)
p2 = spira.Term(name='P2', midpoint=(0, 40), orientation=-90, width=2)
rm = RouteManhattan(port1=p1, port2=p2, radius=8)
return spira.SRef(rm, midpoint=(150, 0))
