KCell¶

A KCell is like an empty canvas, where you can add polygons, instances to other Cells and ports (to connect to other cells)

In KLayout geometries are in datatabase units (dbu) or microns. GDS uses an integer grid as a basis for geometries. The default is 0.001, i.e. 1nm grid size (0.001 microns)

• Point, Box, Polygon, Edge, Region are in dbu
• DPoint, DBox, DPolygon, DEdge are in microns

Most Shape types are available as microns and dbu parts. They can be converted with <ShapeTypeDBU>.to_dtype(dbu) to microns and with <ShapeTypeMicrons>.to_itype(dbu) where dbu is the the conversion of one database unit to microns. Alternatively they can be converted with c.kcl.to_um(<ShapeTypeDBU>) or c.kcl.to_dbu(<ShapeTypeMicrons>) where c.kcl is the KCell and kcl is the KCLayout which owns the KCell.

In [1]:

import kfactory as kf
import numpy as np

import kfactory as kf import numpy as np

In [2]:

# Define Layers

class LayerInfos(kf.LayerInfos):
    WG: kf.kdb.LayerInfo = kf.kdb.LayerInfo(1,0)
    WGEX: kf.kdb.LayerInfo = kf.kdb.LayerInfo(2,0) # WG Exclude
    CLAD: kf.kdb.LayerInfo = kf.kdb.LayerInfo(4,0) # cladding
    FLOORPLAN: kf.kdb.LayerInfo = kf.kdb.LayerInfo(10,0)

# Make the layout object aware of the new layers:
LAYER = LayerInfos()
kf.kcl.infos = LAYER

# Define Layers class LayerInfos(kf.LayerInfos): WG: kf.kdb.LayerInfo = kf.kdb.LayerInfo(1,0) WGEX: kf.kdb.LayerInfo = kf.kdb.LayerInfo(2,0) # WG Exclude CLAD: kf.kdb.LayerInfo = kf.kdb.LayerInfo(4,0) # cladding FLOORPLAN: kf.kdb.LayerInfo = kf.kdb.LayerInfo(10,0) # Make the layout object aware of the new layers: LAYER = LayerInfos() kf.kcl.infos = LAYER

In [3]:

# Create a blank cell (essentially an empty GDS cell with some special features)
c = kf.KCell()

# Create a blank cell (essentially an empty GDS cell with some special features) c = kf.KCell()

In [4]:

# Create and add a polygon from separate lists of x points and y points
# (Can also be added like [(x1,y1), (x2,y2), (x3,y3), ... ]
poly1 = kf.kdb.DPolygon(
    [
        kf.kdb.DPoint(-8, -6),
        kf.kdb.DPoint(6, 8),
        kf.kdb.DPoint(7, 17),
        kf.kdb.DPoint(9, 5),
    ]
)

# Create and add a polygon from separate lists of x points and y points # (Can also be added like [(x1,y1), (x2,y2), (x3,y3), ... ] poly1 = kf.kdb.DPolygon( [ kf.kdb.DPoint(-8, -6), kf.kdb.DPoint(6, 8), kf.kdb.DPoint(7, 17), kf.kdb.DPoint(9, 5), ] )

In [5]:

c.shapes(c.kcl.find_layer(1, 0)).insert(poly1)

c.shapes(c.kcl.find_layer(1, 0)).insert(poly1)

Out[5]:

polygon (-8000,-6000;6000,8000;7000,17000;9000,5000)

In [6]:

c.show()  # show in klayout
c.plot()

c.show() # show in klayout c.plot()

Exercise :

Make a cell similar to the one above that has a second polygon in layer (2, 0)

Solution :

In [7]:

c = kf.KCell()
points = np.array([(-8, -6), (6, 8), (7, 17), (9, 5)])
poly = kf.polygon_from_array(points)
c.shapes(c.kcl.find_layer(1, 0)).insert(poly1)
c.shapes(c.kcl.find_layer(2, 0)).insert(poly1)
c

c = kf.KCell() points = np.array([(-8, -6), (6, 8), (7, 17), (9, 5)]) poly = kf.polygon_from_array(points) c.shapes(c.kcl.find_layer(1, 0)).insert(poly1) c.shapes(c.kcl.find_layer(2, 0)).insert(poly1) c

In [8]:

c = kf.KCell()
textgenerator = kf.kdb.TextGenerator.default_generator()
t = textgenerator.text("Hello!", c.kcl.dbu)
c.shapes(kf.kcl.find_layer(1, 0)).insert(t)
c.show()  # show in klayout
c.plot()

c = kf.KCell() textgenerator = kf.kdb.TextGenerator.default_generator() t = textgenerator.text("Hello!", c.kcl.dbu) c.shapes(kf.kcl.find_layer(1, 0)).insert(t) c.show() # show in klayout c.plot()

In [9]:

r = kf.kdb.DBox(-2.5, -5, 2.5, 5)
r

r = kf.kdb.DBox(-2.5, -5, 2.5, 5) r

Out[9]:

(-2.5,-5;2.5,5)

Add instances to the new geometry to c, our blank cell

In [10]:

c = kf.KCell()
c.shapes(c.kcl.find_layer(1, 0)).insert(r)
c.shapes(c.kcl.find_layer(2, 0)).insert(r)
c

c = kf.KCell() c.shapes(c.kcl.find_layer(1, 0)).insert(r) c.shapes(c.kcl.find_layer(2, 0)).insert(r) c

In [11]:

c = kf.KCell()
textgenerator = kf.kdb.TextGenerator.default_generator()
text1 = t.transformed(
    kf.kdb.DTrans(0.0, 10.0).to_itype(c.kcl.dbu)
)  # DTrans is a transformation in microns with arguments (<rotation in 90° increments>, <mirror boolean>, <x in microns>, <y in microns>)
# Now that the geometry has been added to "c", we can move everything around:

c = kf.KCell() textgenerator = kf.kdb.TextGenerator.default_generator() text1 = t.transformed( kf.kdb.DTrans(0.0, 10.0).to_itype(c.kcl.dbu) ) # DTrans is a transformation in microns with arguments (, , , ) # Now that the geometry has been added to "c", we can move everything around:

In [12]:

### complex transformation example:ce
#     magnification(float): magnification, DO NOT USE on cells or instances, only shapes, most foundries will not allow magnifications on actual cell instances or cells
#     rotation(float): rotation in degrees
#     mirror(bool): boolean to mirror at x axis and then rotate if true
#     x(float): x coordinate
#     y(float): y coordinate
#
text2 = t.transformed(
    kf.kdb.DCplxTrans(2.0, 45.0, False, 5.0, 30.0).to_itrans(c.kcl.dbu)
)
# text1.movey(25)
# text2.move([5, 30])
# text2.rotate(45)
r.move(
    -5, 0
)  # boxes can be moved like this, other shapes and cellss/refs need to be moved with .transform
r.move(-5, 0)

### complex transformation example:ce # magnification(float): magnification, DO NOT USE on cells or instances, only shapes, most foundries will not allow magnifications on actual cell instances or cells # rotation(float): rotation in degrees # mirror(bool): boolean to mirror at x axis and then rotate if true # x(float): x coordinate # y(float): y coordinate # text2 = t.transformed( kf.kdb.DCplxTrans(2.0, 45.0, False, 5.0, 30.0).to_itrans(c.kcl.dbu) ) # text1.movey(25) # text2.move([5, 30]) # text2.rotate(45) r.move( -5, 0 ) # boxes can be moved like this, other shapes and cellss/refs need to be moved with .transform r.move(-5, 0)

Out[12]:

(-12.5,-5;-7.5,5)

In [13]:

c.shapes(c.kcl.find_layer(1, 0)).insert(text1)
c.shapes(c.kcl.find_layer(2, 0)).insert(text2)
c.shapes(c.kcl.find_layer(2, 0)).insert(r)

c.shapes(c.kcl.find_layer(1, 0)).insert(text1) c.shapes(c.kcl.find_layer(2, 0)).insert(text2) c.shapes(c.kcl.find_layer(2, 0)).insert(r)

Out[13]:

box (-12500,-5000;-7500,5000)

In [14]:

c.show()  # show in klayout
c.plot()

c.show() # show in klayout c.plot()

connect ports¶

Cells can have a "Port" that allows you to connect Instances together like legos.

You can write a simple function to make a rectangular straight, assign ports to the ends, and then connect those rectangles together.

In [15]:

@kf.cell
def straight(length=10, width=1, layer=(1, 0)):
    wg = kf.KCell()
    box = kf.kdb.DBox(length, width)
    int_box = wg.kcl.to_dbu(box)
    _layer = kf.kcl.find_layer(*layer)
    wg.shapes(_layer).insert(box)
    wg.add_port(
        kf.Port(
            name="o1",
            dwidth=width,
            dcplx_trans=kf.kdb.DCplxTrans(1, 180, False, box.left, box.center().y),
            layer=_layer,
        )
    )
    wg.create_port(
        name="o2",
        trans=kf.kdb.Trans(int_box.right, int_box.center().y),
        layer=_layer,
        width=int_box.height(),
    )
    return wg

@kf.cell def straight(length=10, width=1, layer=(1, 0)): wg = kf.KCell() box = kf.kdb.DBox(length, width) int_box = wg.kcl.to_dbu(box) _layer = kf.kcl.find_layer(*layer) wg.shapes(_layer).insert(box) wg.add_port( kf.Port( name="o1", dwidth=width, dcplx_trans=kf.kdb.DCplxTrans(1, 180, False, box.left, box.center().y), layer=_layer, ) ) wg.create_port( name="o2", trans=kf.kdb.Trans(int_box.right, int_box.center().y), layer=_layer, width=int_box.height(), ) return wg

In [16]:

c = kf.KCell()
wg1 = c << straight(length=1, width=2.5, layer=(1, 0))
wg2 = c << straight(length=2, width=2.5, layer=(1, 0))
wg3 = c << straight(length=3, width=2.5, layer=(1, 0))
c

c = kf.KCell() wg1 = c << straight(length=1, width=2.5, layer=(1, 0)) wg2 = c << straight(length=2, width=2.5, layer=(1, 0)) wg3 = c << straight(length=3, width=2.5, layer=(1, 0)) c

Now we can align everything together using the ports:

Each straight has two ports: 'o1' and 'o2'. These are arbitrary names defined in our straight() function above

In [17]:

# Let's keep wg1 in place on the bottom, and connect the other straights to it.
# To do that, on wg2 we'll grab the "W0" port and connect it to the "E0" on wg1:
wg2.connect("o1", wg1.ports["o2"])
# Next, on wg3 let's grab the "W0" port and connect it to the "E0" on wg2:
wg3.connect("o1", wg2.ports["o2"])
c

# Let's keep wg1 in place on the bottom, and connect the other straights to it. # To do that, on wg2 we'll grab the "W0" port and connect it to the "E0" on wg1: wg2.connect("o1", wg1.ports["o2"]) # Next, on wg3 let's grab the "W0" port and connect it to the "E0" on wg2: wg3.connect("o1", wg2.ports["o2"]) c

In [18]:

c.add_port(name="o1", port=wg1.ports["o1"])
c.add_port(name="o2", port=wg3.ports["o2"])
c.show()  # show in klayout
c.plot()

c.add_port(name="o1", port=wg1.ports["o1"]) c.add_port(name="o2", port=wg3.ports["o2"]) c.show() # show in klayout c.plot()

As you can see the red labels are for the cell ports while blue labels are for the sub-ports (children ports)

Move and rotate instances¶

You can move, rotate, and reflect instances to Cells.

In [19]:

c = kf.KCell()

c = kf.KCell()

In [20]:

# Create and add a polygon from separate lists of x points and y points
# e.g. [(x1, x2, x3, ...), (y1, y2, y3, ...)]
c.shapes(c.kcl.find_layer(4, 0)).insert(
    kf.kdb.DPolygon([kf.kdb.DPoint(x, y) for x, y in zip((8, 6, 7, 9), (6, 8, 9, 5))])
)

# Create and add a polygon from separate lists of x points and y points # e.g. [(x1, x2, x3, ...), (y1, y2, y3, ...)] c.shapes(c.kcl.find_layer(4, 0)).insert( kf.kdb.DPolygon([kf.kdb.DPoint(x, y) for x, y in zip((8, 6, 7, 9), (6, 8, 9, 5))]) )

Out[20]:

polygon (9000,5000;6000,8000;7000,9000)

In [21]:

# Alternatively, create and add a polygon from a list of points
# e.g. [(x1,y1), (x2,y2), (x3,y3), ...] using the same function
c.shapes(c.kcl.find_layer(4, 0)).insert(
    kf.kdb.DPolygon(
        [kf.kdb.DPoint(x, y) for (x, y) in ((0, 0), (1, 1), (1, 3), (-3, 3))]
    )
)

# Alternatively, create and add a polygon from a list of points # e.g. [(x1,y1), (x2,y2), (x3,y3), ...] using the same function c.shapes(c.kcl.find_layer(4, 0)).insert( kf.kdb.DPolygon( [kf.kdb.DPoint(x, y) for (x, y) in ((0, 0), (1, 1), (1, 3), (-3, 3))] ) )

Out[21]:

polygon (0,0;-3000,3000;1000,3000;1000,1000)

In [22]:

c.show()  # show in klayout
c.plot()

c.show() # show in klayout c.plot()

Ports¶

Your straights wg1/wg2/wg3 are instances to other straight cells.

If you want to add ports to the new Cell c you can use add_port, where you can create a new port or use an instance an existing port from the underlying instance.

You can access the ports of a Cell or Instance

In [23]:

wg2.ports

wg2.ports

Out[23]:

['Port(name: o1, dwidth: 2.5, trans: r180 *1 0.5,0, layer: WG (1/0), port_type: optical)', 'Port(name: o2, dwidth: 2.5, trans: r0 *1 2.5,0, layer: WG (1/0), port_type: optical)']

Instances¶

Now that we have your cell c is a multi-straight cell, you can add instances to that cell in a new blank Cell c2, then add two instances and shift one to see the movement.

In [24]:

c2 = kf.KCell(name="MultiMultiWaveguide")
wg1 = straight(layer=(2, 0))
wg2 = straight(layer=(2, 0))
mwg1_ref = c2.create_inst(wg1)
mwg2_ref = c2.create_inst(wg2)
mwg2_ref.transform(kf.kdb.DTrans(10, 10))
c2

c2 = kf.KCell(name="MultiMultiWaveguide") wg1 = straight(layer=(2, 0)) wg2 = straight(layer=(2, 0)) mwg1_ref = c2.create_inst(wg1) mwg2_ref = c2.create_inst(wg2) mwg2_ref.transform(kf.kdb.DTrans(10, 10)) c2

In [25]:

# Like before, let's connect mwg1 and mwg2 together
mwg1_ref.connect("o2", mwg2_ref.ports["o1"])

# Like before, let's connect mwg1 and mwg2 together mwg1_ref.connect("o2", mwg2_ref.ports["o1"])

In [26]:

c2

c2

In [27]:

c = kf.KCell()
bend = kf.cells.euler.bend_euler(radius=10, width=1, layer=LAYER.WG)
b1 = c << bend
b2 = c << bend
b2.mirror_x(x=0)
c

c = kf.KCell() bend = kf.cells.euler.bend_euler(radius=10, width=1, layer=LAYER.WG) b1 = c << bend b2 = c << bend b2.mirror_x(x=0) c

In [28]:

c = kf.KCell()
bend = kf.cells.euler.bend_euler(radius=10, width=1, layer=LAYER.WG)
b1 = c << bend
b2 = c << bend
b2.mirror_y(y=0)
c

c = kf.KCell() bend = kf.cells.euler.bend_euler(radius=10, width=1, layer=LAYER.WG) b1 = c << bend b2 = c << bend b2.mirror_y(y=0) c

In [29]:

c = kf.KCell()
bend = kf.cells.euler.bend_euler(radius=10, width=1, layer=LAYER.WG)
b1 = c << bend
b2 = c << bend
b2.mirror_y(y=0)
b1.ymin = b2.ymax
c

c = kf.KCell() bend = kf.cells.euler.bend_euler(radius=10, width=1, layer=LAYER.WG) b1 = c << bend b2 = c << bend b2.mirror_y(y=0) b1.ymin = b2.ymax c

Labels¶

You can add abstract GDS labels (annotate) to your Cells, in order to record information directly into the final GDS file without putting any extra geometry onto any layer This label will display in a GDS viewer, but will not be rendered or printed like the polygons created by gf.cells.text().

In [30]:

c2.shapes(c2.kcl.find_layer(1, 0)).insert(kf.kdb.Text("First label", mwg1_ref.trans))
c2.shapes(c2.kcl.find_layer(1, 0)).insert(kf.kdb.Text("Second label", mwg2_ref.trans))

c2.shapes(c2.kcl.find_layer(1, 0)).insert(kf.kdb.Text("First label", mwg1_ref.trans)) c2.shapes(c2.kcl.find_layer(1, 0)).insert(kf.kdb.Text("Second label", mwg2_ref.trans))

Out[30]:

text ('Second label',m90 0,0)

In [31]:

# It's very useful for recording information about the devices or layout
c2.shapes(c2.kcl.find_layer(10, 0)).insert(
    kf.kdb.Text(
        f"The x size of this\nlayout is {c2.dbbox().width()}",
        kf.kdb.Trans(c2.bbox().right, c2.bbox().top),
    )
)
c2.show()
c2.plot()

# It's very useful for recording information about the devices or layout c2.shapes(c2.kcl.find_layer(10, 0)).insert( kf.kdb.Text( f"The x size of this\nlayout is {c2.dbbox().width()}", kf.kdb.Trans(c2.bbox().right, c2.bbox().top), ) ) c2.show() c2.plot()

Boolean shapes¶

If you want to subtract one shape from another, merge two shapes, or perform an XOR on them, you can do that with the boolean() function.

The operation argument should be {not, and, or, xor, 'A-B', 'B-A', 'A+B'}. Note that 'A+B' is equivalent to 'or', 'A-B' is equivalent to 'not', and 'B-A' is equivalent to 'not' with the operands switched

In [32]:

e1 = kf.kdb.DPolygon.ellipse(kf.kdb.DBox(10, 8), 64)
e2 = kf.kdb.DPolygon.ellipse(kf.kdb.DBox(10, 6), 64).transformed(
    kf.kdb.DTrans(2.0, 0.0)
)

e1 = kf.kdb.DPolygon.ellipse(kf.kdb.DBox(10, 8), 64) e2 = kf.kdb.DPolygon.ellipse(kf.kdb.DBox(10, 6), 64).transformed( kf.kdb.DTrans(2.0, 0.0) )

In [33]:

c = kf.KCell()
c.shapes(c.kcl.find_layer(2, 0)).insert(e1)
c.shapes(c.kcl.find_layer(4, 0)).insert(e2)
c

c = kf.KCell() c.shapes(c.kcl.find_layer(2, 0)).insert(e1) c.shapes(c.kcl.find_layer(4, 0)).insert(e2) c

In [34]:

# e1 NOT e2
c = kf.KCell()
e3 = kf.kdb.Region(c.kcl.to_dbu(e1)) - kf.kdb.Region(c.kcl.to_dbu(e2))
c.shapes(c.kcl.find_layer(1, 0)).insert(e3)
c

# e1 NOT e2 c = kf.KCell() e3 = kf.kdb.Region(c.kcl.to_dbu(e1)) - kf.kdb.Region(c.kcl.to_dbu(e2)) c.shapes(c.kcl.find_layer(1, 0)).insert(e3) c

In [35]:

# e1 AND e2
c = kf.KCell()
e3 = kf.kdb.Region(c.kcl.to_dbu(e1)) & kf.kdb.Region(c.kcl.to_dbu(e2))
c.shapes(c.kcl.find_layer(1, 0)).insert(e3)
c

# e1 AND e2 c = kf.KCell() e3 = kf.kdb.Region(c.kcl.to_dbu(e1)) & kf.kdb.Region(c.kcl.to_dbu(e2)) c.shapes(c.kcl.find_layer(1, 0)).insert(e3) c

In [36]:

# e1 OR e2
c = kf.KCell()
e3 = kf.kdb.Region(c.kcl.to_dbu(e1)) + kf.kdb.Region(c.kcl.to_dbu(e2))
c.shapes(c.kcl.find_layer(1, 0)).insert(e3)
c

# e1 OR e2 c = kf.KCell() e3 = kf.kdb.Region(c.kcl.to_dbu(e1)) + kf.kdb.Region(c.kcl.to_dbu(e2)) c.shapes(c.kcl.find_layer(1, 0)).insert(e3) c

In [37]:

# e1 OR e2 (merged)
c = kf.KCell()
e3 = (
    kf.kdb.Region(c.kcl.to_dbu(e1)) + kf.kdb.Region(c.kcl.to_dbu(e2))
).merge()
c.shapes(c.kcl.find_layer(1, 0)).insert(e3)
c

# e1 OR e2 (merged) c = kf.KCell() e3 = ( kf.kdb.Region(c.kcl.to_dbu(e1)) + kf.kdb.Region(c.kcl.to_dbu(e2)) ).merge() c.shapes(c.kcl.find_layer(1, 0)).insert(e3) c

In [38]:

# e1 XOR e2
c = kf.KCell()
e3 = kf.kdb.Region(c.kcl.to_dbu(e1)) ^ kf.kdb.Region(c.kcl.to_dbu(e2))
c.shapes(c.kcl.find_layer(1, 0)).insert(e3)
c

# e1 XOR e2 c = kf.KCell() e3 = kf.kdb.Region(c.kcl.to_dbu(e1)) ^ kf.kdb.Region(c.kcl.to_dbu(e2)) c.shapes(c.kcl.find_layer(1, 0)).insert(e3) c

Move instance by port¶

In [39]:

c = kf.KCell()
wg = c << kf.cells.straight.straight(width=0.5, length=1, layer=LAYER.WG)
bend = c << kf.cells.euler.bend_euler(width=0.5, radius=1, layer=LAYER.WG)

bend.connect("o1", wg.ports["o2"])  # connects follow Source, destination syntax
c

c = kf.KCell() wg = c << kf.cells.straight.straight(width=0.5, length=1, layer=LAYER.WG) bend = c << kf.cells.euler.bend_euler(width=0.5, radius=1, layer=LAYER.WG) bend.connect("o1", wg.ports["o2"]) # connects follow Source, destination syntax c

Rotate instance¶

You can rotate in degrees using Instance.drotate or in multiples of 90 deg.

In [40]:

c = kf.KCell("mirror_example3")
bend = kf.cells.euler.bend_euler(width=0.5, radius=1, layer=LAYER.WG)
b1 = c << bend
b2 = c << bend
b2.drotate(90)
c

c = kf.KCell("mirror_example3") bend = kf.cells.euler.bend_euler(width=0.5, radius=1, layer=LAYER.WG) b1 = c << bend b2 = c << bend b2.drotate(90) c

In [41]:

c = kf.KCell("mirror_example4")
bend = kf.cells.euler.bend_euler(width=0.5, radius=1, layer=LAYER.WG)
b1 = c << bend
b2 = c << bend
b2.rotate(1)
c

c = kf.KCell("mirror_example4") bend = kf.cells.euler.bend_euler(width=0.5, radius=1, layer=LAYER.WG) b1 = c << bend b2 = c << bend b2.rotate(1) c

By default the mirror works along the x=0 axis.

Write GDS¶

GDSII is the Standard format for exchanging CMOS circuits with foundries

You can write your Cell to GDS file.

In [42]:

c.write("demo.gds")

c.write("demo.gds")