def test_elem_layer(): l1 = spira.Layer() l2 = spira.Layer(number=18, datatype=3) l3 = spira.Layer(number=18, datatype=3) assert l1.key == (0, 0) assert l2.key == (18, 3) assert l2.key != (18, 0) assert l1 != l2 assert l2 == l3 p1 = PurposeLayer(name='Metals') p2 = PurposeLayer(name='Ground') p3 = PurposeLayer(name='Skyplane', datatype=3) p4 = PurposeLayer(name='Skyplane', datatype=2) assert p1.name == 'Metals' assert p1 == p2 assert p1 != p3 p5 = p3 + p4 assert p5.datatype == 5 assert p3.datatype == 3 p6 = p3 + 6 assert p6.datatype == 9 p6 += p3 assert p6.datatype == 12
def create_elements(self, elems): group = spira.Group() group += spira.Rectangle(p1=(0, 0), p2=(10, 10), layer=spira.Layer(1)) group += spira.Rectangle(p1=(0, 15), p2=(10, 30), layer=spira.Layer(1)) group.transform(self.group_transform) elems += group bbox_shape = group.bbox_info.bounding_box(margin=1) elems += spira.Polygon(shape=bbox_shape, layer=spira.Layer(2)) return elems
def create_t1(self): T = self.get_transforms() ply = spira.Rectangle(p1=(0, 0), p2=(self.width, self.length), layer=spira.Layer(number=2)) ply.transform(transformation=T) return ply
def create_t1(self): T = spira.Translation(Coord(-10, 0)) ply = spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=2)) ply.transform(T) return ply
def create_t1(self): T = spira.Rotation(rotation=-30) ply = spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=2)) ply.transform(T) return ply
def create_t2(self): tf = spira.GenericTransform(translation=Coord(-22, 0)) ply = spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=3), transformation=tf) return ply
def create_t2(self): T = spira.GenericTransform(rotation=-60) ply = spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=3), transformation=T) return ply
def wrap_labels(cell, c2dmap): for l in cell.get_labels(): D = c2dmap[cell] if isinstance(l, gdspy.Label): D += spira.Label(position=l.position, text=l.text, layer=spira.Layer(number=l.layer))
def create_t3(self): cell = spira.Cell() cell += spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=4)) S = spira.SRef(cell) S.rotate(-90) return S
def create_t2(self): cell = spira.Cell() cell += spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=3)) T = spira.GenericTransform(rotation=-60) S = spira.SRef(cell, transformation=T) return S
def create_t1(self): cell = spira.Cell() cell += spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=2)) T = spira.Rotation(-30) S = spira.SRef(cell, transformation=T) return S
def create_t3(self): ply = spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=4)) ply.translate((30, 0)) ply.rotate(90) # FIXME: Reflection is not working. ply.reflect(True) return ply
def parse(self): gdsii_lib = gdspy.GdsLibrary(name='SPiRA-cell') gdsii_lib.read_gds(self.file_name) top_level_gdspy_cells = gdsii_lib.top_level() if self.cell_name is not None: if self.cell_name not in gdsii_lib.cell_dict: error_message = "[SPiRA] import_gds() The requested gdspy_cell (named {}) is not present in file {}" raise ValueError(error_message.format(self.cell_name, self.file_name)) topgdspy_cell = gdsii_lib.cell_dict[self.cell_name] elif self.cell_name is None and len(top_level_gdspy_cells) == 1: topgdspy_cell = top_level_gdspy_cells[0] elif self.cell_name is None and len(top_level_gdspy_cells) > 1: # TODO: Add this to logger. print('Multiple toplevel gdspy_cells found:') for gdspy_cell in top_level_gdspy_cells: print(gdspy_cell) raise ValueError('[SPiRA] import_gds() There are multiple' + 'top-level gdspy_cells, you must specify self.cell_name' + 'to select of one of them') c2dmap = {} for gdspy_cell in gdsii_lib.cell_dict.values(): D = spira.Cell(name=gdspy_cell.name) for e in gdspy_cell.polygons: for i, p in enumerate(e.polygons): n = e.layers[i] d = e.datatypes[i] # print(n, d) layer = spira.Layer(number=int(n), datatype=int(d)) L = self.map_layer(layer) # print(L) # D += spira.Polygon(shape=p, layer=L) ply = spira.Polygon(shape=p, layer=L) # print(ply) D += ply # print(e.datatypes) # key = (e.layer) # # FIXME: Maybe check the datatype and add layer mapping. # for n, p in zip(e.layers, e.polygons): # layer = spira.Layer(number=int(n), datatype=int(0)) # L = self.map_layer(layer) # D += spira.Polygon(shape=p, layer=L) c2dmap.update({gdspy_cell: D}) for gdspy_cell in gdsii_lib.cell_dict.values(): self._create_references(gdspy_cell, c2dmap) # self._create_labels(gdspy_cell, c2dmap) return c2dmap[topgdspy_cell]
def import_gds(filename, cellname=None, flatten=False, pcell=True): """ """ 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 = [] c2dmap = {} for cell in gdsii_lib.cell_dict.values(): D = spira.Cell(name=cell.name) for e in cell.polygons: # FIXME: Maybe check the datatype and add layer mapping. for n, p in zip(e.layers, e.polygons): layer = spira.Layer(number=int(n), datatype=0) D += spira.Polygon(shape=p, layer=layer) c2dmap.update({cell: D}) cell_list.append(cell) for cell in cell_list: wrap_references(cell, c2dmap) # wrap_labels(cell, c2dmap) top_spira_cell = c2dmap[topcell] if flatten == True: C = spira.Cell(name='import_gds') else: C = top_spira_cell if pcell is True: D = parameterize_cell(C) else: D = C return D
def create_t3(self): cell = spira.Cell() tf_1 = spira.Translation(Coord(12.5, 2.5)) + spira.Rotation(60) tf_2 = spira.Translation(Coord( 12.5, 2.5)) + spira.Rotation(60) + spira.Reflection(True) cell += spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=4)) S1 = spira.SRef(cell, transformation=tf_1) S2 = spira.SRef(cell, transformation=tf_2) return [S1, S2]
def create_t2(self): cell = spira.Cell() tf_1 = spira.GenericTransform(translation=(10, 10), rotation=45) tf_2 = spira.GenericTransform(translation=Coord(10, 10), rotation=45, reflection=True) cell += spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=3)) S1 = spira.SRef(cell, transformation=tf_1) S2 = spira.SRef(cell, transformation=tf_2) return [S1, S2]
def create_elements(self, elems): points = [(10.0, 0.0), (15.0, 10.0), (0.0, 10.0), (0.0, 5.0), (-15.0, 5.0), (-5.0, 0.0), (-10.0, -10.0), (-5.0, -15.0), (10.0, -15.0), (5.0, -10.0), (5.0, -5.0)] s = spira.Shape(points=points) S1 = spira.Cell(name='shape', elements=spira.Polygon(shape=s, layer=spira.Layer(1))) # #translate a copy of the shape # t = s.move_copy((0.0, 20.0)) # S2 = Structure("shape_trans", Boundary(Layer(0), t)) # #rotate the shape (angle in degree) # t = s.rotate_copy((0.0, 0.0), 50) # S3 = Structure("shape_rot", Boundary(Layer(0), t)) # #scale the shape # t = s.magnify_copy((0.0, 0.0), 1.2) # S4 = Structure("shape_scale", Boundary(Layer(0), t)) # #stretch the shape horizontally and squeeze vertically # t = Stretch(stretch_center = (0.0, 0.0), stretch_factor = (1.5, 0.5))(s) # S5 = Structure("shape_stretch", Boundary(Layer(0), t)) # #fit the shape in a box # south_west = (-7.0, -7.0) # north_east = (7.0, 7.0) # t = ShapeFit(s, south_west, north_east) # S6 = Structure("shape_fit", Boundary(Layer(0), t)) # #create a shape which traces the contour with a certain line width # t = ShapePath(original_shape = s, path_width = 0.5) # S7 = Structure("ShapePath1", Boundary(Layer(0), t)) # t = ShapePathRounded(original_shape = s, path_width = 0.5) # S8 = Structure("ShapePath2", Boundary(Layer(0), t)) # #expand the shape with a certain distance # t = ShapeGrow(s, 1.0) # S9 = Structure("shape_grow", Boundary(Layer(1), t) + Boundary(Layer(0), s)) # #round the shape with a given radius # t = ShapeRound(original_shape = s, radius = 2.0) # S10 = Structure("shape_round", Boundary(Layer(1), t) + Boundary(Layer(0), s)) elems += [ spira.SRef(S1, (0.0, 200.0)), ] return elems
def create_elements(self, elems): t1, t2 = self.get_transforms() jj = Junction() elems += spira.SRef(alias='ref_jj1', reference=jj, transformation=t1) elems += spira.SRef(alias='ref_jj2', reference=jj, transformation=t2) elems += spira.Rectangle(p1=(7, -13), p2=(143, 1), layer=spira.Layer(number=2)) return elems
def test_elem_polygon(): p1 = [[[0, 0], [3, 0], [3, 1], [0, 1]]] p2 = [[[4, 0], [7, 0], [7, 1], [4, 1]]] p3 = [[[8, 0], [11, 0], [11, 1], [8, 1]]] # Create polygon using class parameters. ply1 = spira.Polygon(p1) assert issubclass(type(ply1.shape), shapes.Shape) assert ply1.gds_layer.number == 0 assert ply1.gds_layer.datatype == 0 # Create polygon using new layer number. ply2 = spira.Polygon(shape=p2, gds_layer=spira.Layer(number=77)) assert issubclass(type(ply2.shape), shapes.Shape) assert ply2.gds_layer.number == 77 assert ply2.gds_layer.datatype == 0 # Create polygon using new shape, number and datatype. ply3 = spira.Polygon(shape=shapes.Shape(points=p3), gds_layer=spira.Layer(number=51, datatype=1)) assert issubclass(type(ply3.shape), shapes.Shape) assert ply3.gds_layer.number == 51 assert ply3.gds_layer.datatype == 1
class Box(spira.Cell): width = spira.NumberParameter(default=1) height = spira.NumberParameter(default=1) layer = spira.LayerParameter(default=spira.Layer(1)) def create_elements(self, elems): shape = shapes.BoxShape(width=self.width, height=self.height) elems += spira.Polygon(shape=shape, layer=self.layer) return elems def create_ports(self, ports): ports += spira.Port(name='P1_M1', midpoint=(-0.5,0), orientation=180, width=1) ports += spira.Port(name='P2_M1', midpoint=(0.5,0), orientation=0, width=1) return ports
def create_t1(self): cell = spira.Cell() cell += spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=2)) S1 = spira.SRef(cell) S1.rotate(rotation=45) S1.translate(Coord(15, 15)) S = spira.SRef(cell) S.rotate(rotation=45) S.translate(Coord(15, 15)) S.reflect(True) return [S1, S]
def create_ref_point(self): return spira.Rectangle(p1=(-2.5, -2.5), p2=(2.5, 2.5), layer=spira.Layer(number=1))
def create_elements(self, elems): elems += spira.Rectangle(p1=(0,0), p2=(20,5), layer=spira.Layer(1)) return elems
# rect = spira.Polygon(shape=rect_shape, layer=spira.Layer(number=16)) # rect.center = (15,0) # cell += rect # box = spira.Polygon(shape=box_shape, layer=spira.Layer(number=17)) # box.center = (20,0) # cell += box # FIXME # basic = spira.Polygon(shape=basic_tri_shape, layer=spira.Layer(number=18)) # basic.center = (25,0) # cell += basic # FIXME # tri = spira.Polygon(shape=tri_shape, layer=spira.Layer(number=19)) # tri.center = (30,0) # cell += tri # FIXME # arrow = spira.Polygon(shape=arrow_shape, layer=spira.Layer(number=15)) # arrow.center = (10,0) # cell += arrow # NOTE: Advanced shapes ytron_shape = YtronShape() ytron = spira.Polygon(shape=ytron_shape, layer=spira.Layer(number=20)) ytron.center = (35, 0) cell += ytron cell.gdsii_output()
def create_elements(self, elems): pts = [[0, 0], [2, 2], [2, 6], [-6, 6], [-6, -6], [-4, -4], [-4, 4], [0, 4]] shape = spira.Shape(points=pts) elems += spira.Polygon(shape=shape, layer=spira.Layer(1)) return elems
def _create_labels(self, gdspy_cell, c2dmap): for l in gdspy_cell.get_labels(): D = c2dmap[gdspy_cell] if isinstance(l, gdspy.Label): D += spira.Label(position=l.position, text=l.text, layer=spira.Layer(number=l.layer))
import spira.all as spira ll = spira.LayerList() ll += spira.Layer(1) ll += spira.Layer(2) print(ll) # lf = spira.LayerFilterDelete(layers=ll) lf = spira.LayerFilterAllow(layers=ll) print(lf.layers) print(len(lf.layers)) print(lf) p1 = spira.Rectangle(layer=spira.Layer(1)) p2 = spira.Rectangle(layer=spira.Layer(3)) F = lf([p1, p2]) print(F)
def create_t3(self): ply = spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=4)) ply.rotate(-90) return ply
def create_t3(self): ply = spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=4)) ply.reflect(True) return ply
def create_t3(self): ply = spira.Rectangle(p1=(0, 0), p2=(10, 50), layer=spira.Layer(number=4)) ply.translate((-34, 0)) return ply