def write(self, item):
self.collect(item)
writer = gdspy.GdsWriter('{}.gds'.format(self.file_name),
unit=1.0e-6,
precision=1.0e-12)
for cell in self.collector.values():
writer.write_cell(cell)
del cell
writer.close()
def save(cell, filename, unit=1e-6, precision=1e-9):
#=====================
# Save cell to a file \\
#=========================================================================
# Arguments: cell : gdspy cell object or a list of cells ||
# filename : filename to write to (relative path) ||
#=========================================================================
writer = gp.GdsWriter(filename, unit=unit, precision=precision)
if type(cell) == type([]):
for cell_item in cell:
writer.write_cell(cell_item)
else:
writer.write_cell(cell)
return writer.close()
def gds(self, filename=None, view=False, extra=0, units='nms'):
#check to make sure the geometry isn't an array
if len(self.clean_args(None)[0]) != 1:
raise ValueError(
"You have changing geometries, making gds doesn't make sense")
if units == 'nms':
scale = 1
elif units == 'microns':
scale = 10**-3
else:
raise ValueError('Invalid units')
#scale to proper units
sc_radius = self.radius * scale
sc_gap = self.gap * scale
sc_width = self.width * scale
sc_length = self.length * scale
#write to GDS
pathTop = gdspy.Path(sc_width,
(sc_radius + sc_length / 2,
sc_radius + sc_width / 2 + sc_gap / 2 + extra))
pathTop.segment(extra, '-y')
pathTop.arc(sc_radius, 0, -np.pi / 2)
pathTop.segment(sc_length, '-x')
pathTop.arc(sc_radius, -np.pi / 2, -np.pi)
pathTop.segment(extra, '+y')
pathBottom = gdspy.Path(sc_width,
(-sc_radius - sc_width / 2 - sc_length / 2 -
extra, -sc_gap / 2 - sc_width / 2))
pathBottom.segment(
2 * (sc_radius + sc_width / 2) + sc_length + 2 * extra, '+x')
gdspy.current_library = gdspy.GdsLibrary()
path_cell = gdspy.Cell('C0')
path_cell.add(pathTop)
path_cell.add(pathBottom)
if view:
gdspy.LayoutViewer(cells='C0')
if filename is not None:
writer = gdspy.GdsWriter(filename, unit=1.0e-6, precision=1.0e-9)
writer.write_cell(path_cell)
writer.close()
def gds(self, filename=None, extra=0, units='microns', view=False):
"""Writes the geometry to the gds file
Args:
filename (str): location to save file to, or if you don't want to defaults to None
extra (int): extra straight portion to add to ends of waveguides to make room in simulation
(input with units same as units input)
units (str): either 'microns' or 'nms'. Units to save gds file in
"""
#check to make sure the geometry isn't an array
if len(self.clean_args(None)[0]) != 1:
raise ValueError(
"You have changing geometries, making gds doesn't make sense")
if units == 'nms':
scale = 1
elif units == 'microns':
scale = 10**-3
else:
raise ValueError('Invalid units')
#scale to proper units
sc_width = self.width * scale
sc_length = self.length * scale
#write to GDS
path = gdspy.Path(sc_width, (-sc_length / 2 - extra, 0))
path.segment(2 * extra + sc_length, '+x')
gdspy.current_library = gdspy.GdsLibrary()
path_cell = gdspy.Cell('C0')
path_cell.add(path)
if view:
gdspy.LayoutViewer(cells='C0')
if filename is not None:
writer = gdspy.GdsWriter(filename, unit=1.0e-6, precision=1.0e-9)
writer.write_cell(path_cell)
writer.close()
def gdsii_output(self, name=None, view_type='hierarchical', disabled_ports=None, view=True):
_default = {'cells': True, 'polygons': True, 'arrows': True, 'labels': True}
# _default = {'cells': True, 'polygons': False, 'arrows': False, 'labels': False}
if disabled_ports is not None:
_default.update(disabled_ports)
G = OutputGdsii(cell=self, view_type=view_type, disabled_ports=_default)
gdspy_library = gdspy.GdsLibrary(name=self.name)
G.gdspy_gdsii_output(gdspy_library)
if name is not None:
writer = gdspy.GdsWriter('{}.gds'.format(name), unit=1.0e-6, precision=1.0e-12)
for name, cell in gdspy_library.cell_dict.items():
writer.write_cell(cell)
del cell
writer.close()
if view is True:
gdspy.LayoutViewer(library=gdspy_library)
def write_gds_file(main_cell, filename, unit=1.0e-6, precision=1.0e-9):
writer = gdspy.GdsWriter(filename, unit=unit, precision=precision)
for cell in [main_cell] + list(main_cell.get_dependencies(True)):
writer.write_cell(cell)
writer.close()
def test_writer_gds(tmpdir):
lib = gdspy.GdsLibrary()
c1 = gdspy.Cell("gw_rw_gds_1")
c1.add(gdspy.Rectangle((0, -1), (1, 2), 2, 4))
c1.add(gdspy.Label("label", (1, -1), "w", 45, 1.5, True, 5, 6))
c2 = gdspy.Cell("gw_rw_gds_2")
c2.add(gdspy.Round((0, 0), 1, number_of_points=32, max_points=20))
c3 = gdspy.Cell("gw_rw_gds_3")
c3.add(gdspy.CellReference(c1, (0, 1), -90, 2, True))
c4 = gdspy.Cell("gw_rw_gds_4")
c4.add(gdspy.CellArray(c2, 2, 3, (1, 4), (-1, -2), 180, 0.5, True))
lib.add((c1, c2, c3, c4))
fname1 = str(tmpdir.join("test1.gds"))
writer1 = gdspy.GdsWriter(fname1, name="lib", unit=2e-3, precision=1e-5)
for c in lib.cells.values():
writer1.write_cell(c)
writer1.close()
lib1 = gdspy.GdsLibrary(unit=1e-3)
lib1.read_gds(
fname1,
units="convert",
rename={"gw_rw_gds_1": "1"},
layers={2: 4},
datatypes={4: 2},
texttypes={6: 7},
)
assert lib1.name == "lib"
assert len(lib1.cells) == 4
assert set(lib1.cells.keys()) == {"1", "gw_rw_gds_2", "gw_rw_gds_3", "gw_rw_gds_4"}
c = lib1.cells["1"]
assert len(c.polygons) == len(c.labels) == 1
assert c.polygons[0].area() == 12.0
assert c.polygons[0].layers == [4]
assert c.polygons[0].datatypes == [2]
assert c.labels[0].text == "label"
assert c.labels[0].position[0] == 2 and c.labels[0].position[1] == -2
assert c.labels[0].anchor == 4
assert c.labels[0].rotation == 45
assert c.labels[0].magnification == 1.5
assert c.labels[0].x_reflection == True
assert c.labels[0].layer == 5
assert c.labels[0].texttype == 7
c = lib1.cells["gw_rw_gds_2"]
assert len(c.polygons) == 2
assert isinstance(c.polygons[0], gdspy.Polygon) and isinstance(
c.polygons[1], gdspy.Polygon
)
c = lib1.cells["gw_rw_gds_3"]
assert len(c.references) == 1
assert isinstance(c.references[0], gdspy.CellReference)
assert c.references[0].ref_cell == lib1.cells["1"]
assert c.references[0].origin[0] == 0 and c.references[0].origin[1] == 2
assert c.references[0].rotation == -90
assert c.references[0].magnification == 2
assert c.references[0].x_reflection == True
c = lib1.cells["gw_rw_gds_4"]
assert len(c.references) == 1
assert isinstance(c.references[0], gdspy.CellArray)
assert c.references[0].ref_cell == lib1.cells["gw_rw_gds_2"]
assert c.references[0].origin[0] == -2 and c.references[0].origin[1] == -4
assert c.references[0].rotation == 180
assert c.references[0].magnification == 0.5
assert c.references[0].x_reflection == True
assert c.references[0].spacing[0] == 2 and c.references[0].spacing[1] == 8
assert c.references[0].columns == 2
assert c.references[0].rows == 3
fname2 = str(tmpdir.join("test2.gds"))
with open(fname2, "wb") as fout:
writer2 = gdspy.GdsWriter(fout, name="lib2", unit=2e-3, precision=1e-5)
for c in lib.cells.values():
writer2.write_cell(c)
writer2.close()
with open(fname2, "rb") as fin:
lib2 = gdspy.GdsLibrary()
lib2.read_gds(fin)
assert lib2.name == "lib2"
assert len(lib2.cells) == 4
def gds(self,
filename=None,
view=False,
extra=0,
units='nms',
sbend_h=0,
sbend_v=0):
#check to make sure the geometry isn't an array
if len(self.clean_args(None)[0]) != 1:
raise ValueError(
"You have changing geometries, making gds doesn't make sense")
if units == 'nms':
scale = 1
elif units == 'microns':
scale = 10**-3
else:
raise ValueError('Invalid units')
#scale to proper units
sc_width = self.width * scale
sc_gap = self.gap * scale
sc_length = self.length * scale
sc_H = self.H * scale
sc_V = self.V * scale
#make parametric functions
sbendDown = lambda x: (sc_H * x, -sc_V / 2 * (1 - np.cos(np.pi * x)))
sbendUp = lambda x: (sc_H * x, sc_V / 2 * (1 - np.cos(np.pi * x)))
dsbendDown = lambda x: (sc_H, -np.pi * sc_V / 2 * np.sin(np.pi * x))
dsbendUp = lambda x: (sc_H, np.pi * sc_V / 2 * np.sin(np.pi * x))
sbend = False
if sbend_h != 0 and sbend_v != 0:
sbend = True
sbendDownExtra = lambda x: (sbend_h * x, -sbend_v / 2 *
(1 - np.cos(np.pi * x)))
sbendUpExtra = lambda x: (sbend_h * x, sbend_v / 2 *
(1 - np.cos(np.pi * x)))
dsbendDownExtra = lambda x: (sbend_h, -np.pi * sbend_v / 2 * np.sin(
np.pi * x))
dsbendUpExtra = lambda x: (sbend_h, np.pi * sbend_v / 2 * np.sin(np.pi
* x))
#write to GDS
pathTop = gdspy.Path(sc_width,
(-sc_length / 2 - sc_H - sbend_h - extra,
sc_V + sbend_v + sc_width / 2 + sc_gap / 2))
pathTop.segment(extra, '+x')
if sbend: pathTop.parametric(sbendDownExtra, dsbendDownExtra)
pathTop.parametric(sbendDown, dsbendDown)
pathTop.segment(sc_length, '+x')
pathTop.parametric(sbendUp, dsbendUp)
if sbend: pathTop.parametric(sbendUpExtra, dsbendUpExtra)
pathTop.segment(extra, '+x')
pathBottom = gdspy.Path(sc_width,
(-sc_length / 2 - sc_H - sbend_h - extra,
-sc_V - sbend_v - sc_width / 2 - sc_gap / 2))
pathBottom.segment(extra, '+x')
if sbend: pathBottom.parametric(sbendUpExtra, dsbendUpExtra)
pathBottom.parametric(sbendUp, dsbendUp)
pathBottom.segment(sc_length, '+x')
pathBottom.parametric(sbendDown, dsbendDown)
if sbend: pathBottom.parametric(sbendDownExtra, dsbendDownExtra)
pathBottom.segment(extra, '+x')
gdspy.current_library = gdspy.GdsLibrary()
path_cell = gdspy.Cell('C0')
path_cell.add(pathTop)
path_cell.add(pathBottom)
if view:
gdspy.LayoutViewer(cells='C0')
if filename is not None:
writer = gdspy.GdsWriter(filename, unit=1.0e-6, precision=1.0e-9)
writer.write_cell(path_cell)
writer.close()
def gds(self,
filename=None,
extra=0,
units='microns',
view=False,
sbend_h=0,
sbend_v=0):
#check to make sure the geometry isn't an array
if len(self.clean_args(None)[0]) != 1:
raise ValueError(
"You have changing geometries, making gds doesn't make sense")
if units == 'nms':
scale = 1
elif units == 'microns':
scale = 10**-3
else:
raise ValueError('Invalid units')
#scale to proper units
sc_zmin = self.zmin * scale
sc_zmax = self.zmax * scale
sc_width = self.width * scale
cL = (sc_zmax - sc_zmin)
cH = self.gap(self.zmin) * scale / 2
#make parametric functions
paraTop = lambda x: (x * (sc_zmax - sc_zmin) + sc_zmin, scale * self.
gap(x * (self.zmax - self.zmin) + self.zmin
) / 2 + sc_width / 2)
paraBottom = lambda x: (x * (sc_zmax - sc_zmin) + sc_zmin, -scale *
self.gap(x * (self.zmax - self.zmin) + self.
zmin) / 2 - sc_width / 2)
#dparaTop = lambda x: (sc_zmax-sc_zmin, scale*(self.zmax-self.zmin)*self.dgap(x*(self.zmax-self.zmin)+self.zmin)/2)
#dparaBottom = lambda x: (sc_zmax-sc_zmin, -scale*(self.zmax-self.zmin)*self.dgap(x*(self.zmax-self.zmin)+self.zmin)/2)
sbend = False
if sbend_h != 0 and sbend_v != 0:
sbend = True
sbendDown = lambda x: (sbend_h * x, -sbend_v / 2 *
(1 - np.cos(np.pi * x)))
sbendUp = lambda x: (sbend_h * x, sbend_v / 2 *
(1 - np.cos(np.pi * x)))
dsbendDown = lambda x: (sbend_h, -np.pi * sbend_v / 2 * np.sin(np.pi *
x))
dsbendUp = lambda x: (sbend_h, np.pi * sbend_v / 2 * np.sin(np.pi * x))
#write to GDS
pathTop = gdspy.Path(
sc_width, (sc_zmin - extra - sbend_h, cH + sc_width / 2 + sbend_v))
pathTop.segment(extra, '+x')
if sbend: pathTop.parametric(sbendDown, dsbendDown)
pathTop.parametric(paraTop, relative=False)
if sbend: pathTop.parametric(sbendUp, dsbendUp)
pathTop.segment(extra, '+x')
pathBottom = gdspy.Path(
sc_width,
(sc_zmin - extra - sbend_h, -cH - sc_width / 2 - sbend_v))
pathBottom.segment(extra, '+x')
if sbend: pathBottom.parametric(sbendUp, dsbendUp)
pathBottom.parametric(paraBottom, relative=False)
if sbend: pathBottom.parametric(sbendDown, dsbendDown)
pathBottom.segment(extra, '+x')
gdspy.current_library = gdspy.GdsLibrary()
path_cell = gdspy.Cell('C0')
path_cell.add(pathTop)
path_cell.add(pathBottom)
if view:
gdspy.LayoutViewer(cells='C0')
if filename is not None:
writer = gdspy.GdsWriter(filename, unit=1.0e-6, precision=1.0e-9)
writer.write_cell(path_cell)
writer.close()
def gds(self, filename=None, view=False, extra=0, units="nms"):
"""Writes the geometry to the gds file.
Parameters
----------
filename : str, optional
Location to save file to. Defaults to None.
extra : int, optional
Extra straight portion to add to ends of waveguides to make room in simulation
(units same as units parameter). Defaults to 0.
units : {'microns' or 'nms'}, optional
Units to save gds file in. Defaults to microns.
view : bool, optional
Whether to visually show gds file. Defaults to False.
"""
# check to make sure the geometry isn't an array
if len(self._clean_args(None)[0]) != 1:
raise ValueError(
"You have changing geometries, making gds doesn't make sense")
if units == "nms":
scale = 1e-3
elif units == "microns":
scale = 1
else:
raise ValueError("Invalid units")
# scale to proper units
sc_radius = self.radius * scale
sc_gap = self.gap * scale
sc_width = self.width * scale
sc_length = self.length * scale
# write to GDS
pathTop = gdspy.Path(
sc_width,
(-sc_length / 2, 2 * sc_radius + sc_width / 2 + sc_gap / 2))
pathTop.segment(sc_length, "+x")
pathTop.turn(sc_radius, "rr")
pathTop.segment(sc_length, "-x")
pathTop.turn(sc_radius, "rr")
pathBottom = gdspy.Path(
sc_width,
(-sc_radius - sc_width / 2 - sc_length / 2,
-sc_gap / 2 - sc_width / 2),
)
pathBottom.segment(2 * (sc_radius + sc_width / 2) + sc_length, "+x")
gdspy.current_library = gdspy.GdsLibrary()
path_cell = gdspy.Cell("C0")
path_cell.add(pathTop)
path_cell.add(pathBottom)
if view:
gdspy.LayoutViewer(cells="C0")
if filename is not None:
writer = gdspy.GdsWriter(filename, unit=1.0e-6, precision=1.0e-9)
writer.write_cell(path_cell)
writer.close()
def test_writer_gds(tmpdir):
lib = gdspy.GdsLibrary()
c1 = gdspy.Cell('gw_rw_gds_1', True)
c1.add(gdspy.Rectangle((0, -1), (1, 2), 2, 4))
c1.add(gdspy.Label('label', (1, -1), 'w', 45, 1.5, True, 5, 6))
c2 = gdspy.Cell('gw_rw_gds_2', True)
c2.add(gdspy.Round((0, 0), 1, number_of_points=32, max_points=20))
c3 = gdspy.Cell('gw_rw_gds_3', True)
c3.add(gdspy.CellReference(c1, (0, 1), -90, 2, True))
c4 = gdspy.Cell('gw_rw_gds_4', True)
c4.add(gdspy.CellArray(c2, 2, 3, (1, 4), (-1, -2), 180, 0.5, True))
lib.add((c1, c2, c3, c4))
fname1 = str(tmpdir.join('test1.gds'))
writer1 = gdspy.GdsWriter(fname1, name='lib', unit=2e-3, precision=1e-5)
for c in lib.cell_dict.values():
writer1.write_cell(c)
writer1.close()
lib1 = gdspy.GdsLibrary()
lib1.read_gds(fname1, 1e-3, {'gw_rw_gds_1': '1'}, {2: 4}, {4: 2}, {6: 7})
assert lib1.name == 'lib'
assert len(lib1.cell_dict) == 4
assert set(lib1.cell_dict.keys()) == {
'1', 'gw_rw_gds_2', 'gw_rw_gds_3', 'gw_rw_gds_4'
}
c = lib1.cell_dict['1']
assert len(c.elements) == len(c.labels) == 1
assert c.elements[0].area() == 12.0
assert c.elements[0].layer == 4
assert c.elements[0].datatype == 2
assert c.labels[0].text == 'label'
assert c.labels[0].position[0] == 2 and c.labels[0].position[1] == -2
assert c.labels[0].anchor == 4
assert c.labels[0].rotation == 45
assert c.labels[0].magnification == 1.5
assert c.labels[0].x_reflection == True
assert c.labels[0].layer == 5
assert c.labels[0].texttype == 7
c = lib1.cell_dict['gw_rw_gds_2']
assert len(c.elements) == 2
assert isinstance(c.elements[0], gdspy.Polygon) \
and isinstance(c.elements[1], gdspy.Polygon)
c = lib1.cell_dict['gw_rw_gds_3']
assert len(c.elements) == 1
assert isinstance(c.elements[0], gdspy.CellReference)
assert c.elements[0].ref_cell == lib1.cell_dict['1']
assert c.elements[0].origin[0] == 0 and c.elements[0].origin[1] == 2
assert c.elements[0].rotation == -90
assert c.elements[0].magnification == 2
assert c.elements[0].x_reflection == True
c = lib1.cell_dict['gw_rw_gds_4']
assert len(c.elements) == 1
assert isinstance(c.elements[0], gdspy.CellArray)
assert c.elements[0].ref_cell == lib1.cell_dict['gw_rw_gds_2']
assert c.elements[0].origin[0] == -2 and c.elements[0].origin[1] == -4
assert c.elements[0].rotation == 180
assert c.elements[0].magnification == 0.5
assert c.elements[0].x_reflection == True
assert c.elements[0].spacing[0] == 2 and c.elements[0].spacing[1] == 8
assert c.elements[0].columns == 2
assert c.elements[0].rows == 3
fname2 = str(tmpdir.join('test2.gds'))
with open(fname2, 'wb') as fout:
writer2 = gdspy.GdsWriter(fout, name='lib2', unit=2e-3, precision=1e-5)
for c in lib.cell_dict.values():
writer2.write_cell(c)
writer2.close()
with open(fname2, 'rb') as fin:
lib2 = gdspy.GdsLibrary()
lib2.read_gds(fin)
assert lib2.name == 'lib2'
assert len(lib2.cell_dict) == 4
