def create_graph(self, elems):
prim_elems = ElementList()
for S in elems.sref:
if isinstance(S.ref, (NLayer, TLayer, DLayer)):
prim_elems += S
for layer in RDD.METALS.layers:
L = Cell(name='{}'.format(layer))
# ply_elems = D.get_mlayers(layer=layer)
ply_elems = ElementList()
for S in elems.sref:
if isinstance(S.ref, CMLayers):
# print(S.ref.layer)
if S.ref.layer.number == layer:
# print(S)
for p in S.ref.elementals:
# print(p.ref.player)
# FIXME!!!
# if isinstance(p, ELayers):
# raise Errors
if isinstance(p.ref.player, Polygons):
ply_elems += p.ref.player
if ply_elems:
geom = Geometry(name='{}'.format(layer),
lcar=self.lcar,
algorithm=self.algorithm,
layer=layer,
polygons=ply_elems)
mesh_data = geom.create_mesh
params = {
'name': '{}'.format(layer),
'layer': Layer(number=layer),
'point_data': [mesh_data[2]],
'cell_data': [mesh_data[3]],
'field_data': [mesh_data[4]]
}
mesh = Mesh(polygons=ply_elems,
primitives=prim_elems,
points=mesh_data[0],
cells=mesh_data[1],
**params)
L += mesh
elems += SRef(L)
sg = {}
subgraphs = elems.subgraphs
for name, g in subgraphs.items():
graph = Graph(subgraphs={name: g})
sg[name] = graph.g
ng = Graph(subgraphs=sg)
ng.write_graph(graphname='{}'.format(layer))
elems += ng
def terms(self):
from spira.gdsii.elemental.term import Term
terms = ElementList()
for p in self.ports:
if isinstance(p, Term):
terms += p
return terms
def create_box_layer(self):
elems = ElementList()
for p in self.device_elems.polygons:
layer = p.gdslayer.number
# if layer in RDD.GROUND.layers:
if layer == RDD.GDSII.GPLAYER:
l1 = Layer(name='BoundingBox', number=layer, datatype=5)
elems += Polygons(polygons=self.blayer.polygons, gdslayer=l1)
return elems
def create_labels(self):
elems = ElementList()
for p in self.device_elems.polygons:
layer = p.gdslayer.number
# if layer in RDD.GROUND.layers:
if layer == RDD.GDSII.GPLAYER:
l2 = Layer(name='BoundingBox', number=layer, datatype=5)
elems += Port(name='P{}'.format(layer), midpoint=self.blayer.center, gdslayer=l2)
return elems
def create_labels(self):
elems = ElementList()
for p in self.device_elems.polygons:
layer = p.gdslayer.number
players = RDD.PLAYER.get_physical_layers(purposes='METAL')
if layer in players:
l2 = Layer(name='BoundingBox', number=layer, datatype=8)
# FIXME: Ports with the same name overrides eachother.
elems += Port(name='P{}'.format(layer), midpoint=self.blayer.center, gdslayer=l2)
return elems
def create_box_layer(self):
elems = ElementList()
setter = {}
for p in self.device_elems.polygons:
layer = p.gdslayer.number
setter[layer] = 'not_set'
for p in self.device_elems.polygons:
layer = p.gdslayer.number
players = RDD.PLAYER.get_physical_layers(purposes=['METAL'])
if layer in players and setter[layer] == 'not_set':
l1 = Layer(name='BoundingBox', number=layer, datatype=8)
elems += Polygons(polygons=self.blayer.polygons, gdslayer=l1)
setter[layer] = 'already_set'
return elems
def rotate(self, angle=45, center=(0, 0)):
""" Rotates the cell with angle around a center. """
if angle == 0:
return self
for e in self.elementals:
if issubclass(type(e), PolygonAbstract):
e.rotate(angle=angle, center=center)
elif isinstance(e, SRef):
e.rotate(angle, center)
ports = self.ports
self.ports = ElementList()
for p in ports:
if issubclass(type(p), __Port__):
p.midpoint = self.__rotate__(p.midpoint, angle, center)
p.orientation = np.mod(p.orientation + angle, 360)
self.ports += p
return self
def create_devices(self):
deps = self.cell.dependencies()
c2dmap = {}
# for DeviceTCell in self.library.pcells:
# print(RDD.DEVICES.JJ.PCELL)
# for DeviceTCell in RDD.DEVICES.JJ.PCELL:
# print(type(DeviceTCell))
# for C in deps:
# plane_elems = ElementList()
# plane_elems += self.cell.get_purpose_layers(purpose_symbol='GROUND')
# # plane_elems += self.cell.elementals[(RDD.GDSII.GPLAYER, 0)]
# D = Device(cell=C, cell_elems=C.elementals, plane_elems=plane_elems)
# for PrimTCell in DeviceTCell.elementals.sref:
# PrimTCell.ref.create_elementals(D.elementals)
# c2dmap.update({C: D})
for key in RDD.DEVICES.keys:
DeviceTCell = RDD.DEVICES[key].PCELL
for C in deps:
plane_elems = ElementList()
# from spira.gdsii import utils
# players = RDD.PLAYER.get_physical_layers(purposes='GROUND')
# plane_elems += utils.get_purpose_layers(self.cell, players)
# # plane_elems += self.cell.elementals[(RDD.GDSII.GPLAYER, 0)]
D = Device(cell=C,
cell_elems=C.elementals,
plane_elems=plane_elems)
for PrimTCell in DeviceTCell.elementals.sref:
PrimTCell.ref.create_elementals(D.elementals)
c2dmap.update({C: D})
for c in self.cell.dependencies():
self.wrap_references(c, c2dmap)
return SRef(self.cell)
def create_pygmsh_elements(self):
print('number of polygons {}'.format(len(self.polygons)))
height = 0.0
holes = None
elems = ElementList()
for ply in self.polygons:
for i, points in enumerate(ply.polygons):
pp = numpy_to_list(points, height, unit=10e-9)
surface_label = '{}_{}_{}_{}'.format(ply.gdslayer.number,
ply.gdslayer.datatype,
GeometryAbstract._ID, i)
gp = self.geom.add_polygon(pp,
lcar=1.0,
make_surface=True,
holes=holes)
self.geom.add_physical_surface(gp.surface, label=surface_label)
elems += [gp.surface, gp.line_loop]
GeometryAbstract._ID += 1
return elems
def create_elementals(self, elems):
result = ElementList()
return result