import csv
import math

circles = []

Open csv file

with open('circles.csv') as csvfile:
circleReader = csv.reader(csvfile)
for num, row in enumerate(circleReader):
if num != 0:
circles.append((float(row[1]), float(row[2]), float(row[3])))

Open file for output

with open('metalens.cnst','w') as output:

# Header
output.write('# This file is created using metalens.py\n\n')
output.write('0.001 gdsReso\n')
output.write('0.001 shapeReso\n')
output.write('1 layer\n')


# create all circle structures
for num, circle in enumerate(circles, start=1):
    output.write(f'<circle_{num} struct>\n')
    output.write(f'0 0 {circle[1]/2} {circle[1]/2} 0 ellipseVector\n\n')

# create metalens
output.write('# Metalens structure comment\n')
output.write('<metalens struct>\n')

#create each ring of the metalens from the inside out
for num,circle in enumerate(circles, start=1):
    theta = 180*circle[2]/math.pi
    if num == 1:
        output.write(f'<circle_{num} 0 0 N 0 0 instance>\n')
    else:
        output.write(f'<circle_{num} 0 359 {theta} {circle[0]} {circle[0]} 1 1 arrayPolar>\n')

I'd like to share KLayout-klink, an open-source external control layer for a running KLayout GUI, and ask for some feedback on its KLayout API coverage. (https://github.com/klinkdev2026/klayout-klink)

While developing it, I found some older discussions on this forum about controlling an already-running KLayout instance from an external application. In particular, Matthias suggested using socket-based IPC while keeping KLayout itself as the host application.

https://www.klayout.de/forum/discussion/1001/how-to-send-a-ruby-script-for-execution-to-already-open-klayout-editor-instance

https://www.klayout.de/forum/discussion/254/call-reload-from-command-line

klink essentially follows this direction, but tries to turn the task-specific socket "glue code" into a reusable control interface.

Rather than simply providing a remote eval, I went through the KLayout pya and GUI APIs and tried to organize the operations useful for external control into stable, typed APIs.

Currently, the KLayout-facing control surface mainly covers:

1. Layout & Cell — open/save layouts, cell creation/deletion, hierarchy, bbox, etc.
2. Layers — layers/datatypes, layer properties and .lyp
3. Shapes & Geometry — boxes, polygons, paths, text, batch insertion, transforms, boolean/fill
4. Instances / PCells / Libraries — instances, arrays, PCell discovery/creation, libraries and flattening
5. LayoutView / GUI — CellViews, tabs, active cell, viewport, zoom, hierarchy display, highlights and 2.5D view
6. Selection — read/set selection, plus persistent "SEND" selections for external interaction
7. Rulers / Annotations — access and manipulate native KLayout annotations and measurements
8. Editing — grouped transactions, undo/redo
9. DRC / LVS — DRC scripts, netlist extraction/comparison and LVS databases
10. Events / Recording / Sessions — observe GUI/layout changes, record operations and control multiple running KLayout sessions

For things that are not yet covered, exec.python remains an escape hatch to the native pya API.

My own layout background is mainly custom research devices and nanodevices. Although I have tried to systematically go through the KLayout APIs, I do not know all the important workflows in IC layout, mask preparation, MEMS, photonics, PDK-based design and other fields.

So my main question is:

Which KLayout APIs or concepts am I still missing that you think are important enough to deserve a stable external control API?

I do not intend to wrap every pya method individually. I am mainly trying to identify the common, high-value operations that are useful when KLayout is controlled by an external Python program, automation system or MCP/AI client.

Matthias, I would especially appreciate your opinion, since you have seen KLayout used across many more application domains than I have.

Any suggestions or criticism would be very welcome.

Best regards,
Yanming

I installed klayout 0.30.9 in linux system.

from typing import *
import klayout.db as kdb
import klayout.pex as klp


tech1 = klp.RExtractorTech()
tech2 = klp.RExtractorTech()

m1 = 10
m2 = 20
v1 = 15

for l in (m1, m2):
    m = klp.RExtractorTechConductor()
    m.layer = l
    m.resistance = 1
    m.algorithm = klp.Algorithm.Tesselation
    m.triangulation_max_area = 0
    m.triangulation_min_b = 0
    tech1.add_conductor(m)
    m.triangulation_min_b = 0.3
    tech2.add_conductor(m)

v = klp.RExtractorTechVia()
v.cut_layer = v1
v.bottom_conductor = m1
v.top_conductor = m2
v.resistance = 1
tech1.add_via(v)
tech2.add_via(v)

points = """-13025.42800    -33338.54100
-13127.95900    -33236.01000
-13132.73200    -33240.78300
-13135.91400    -33237.60100
-13026.13600    -33127.82300
-12923.60500    -33230.35400
-12920.42300    -33227.17200
-13022.95400    -33124.64100
-13014.99900    -33116.68600
-13011.81700    -33119.86800
-13016.59000    -33124.64100
-12914.05900    -33227.17200
-12923.60500    -33236.71800
-13026.13600    -33134.18700
-13029.31700    -33137.36900
-12926.78700    -33239.89900
-12936.33300    -33249.44500
-13038.86300    -33146.91500
-13042.04500    -33150.09700
-12939.51500    -33252.62700
-12949.06100    -33262.17300
-13051.59100    -33159.64300
-13054.77300    -33162.82500
-12952.24300    -33265.35500
-13012.70100    -33325.81300
-13115.23100    -33223.28300
-13118.41300    -33226.46400
-13015.88200    -33328.99500"""

points = points.split("\n")
points_kdb = []
for p in points:
    x, y = p.split()
    points_kdb.append(kdb.Point(round(float(x)/0.001), round(float(y)/0.001)))

polygon = kdb.Polygon(points_kdb)
region = kdb.Region([polygon])
geo: Dict[int, kdb.Region] = {m1: region}

x1, y1 = -13133, -33238.8
x2, y2 = -13015,-33120
port_a = kdb.Point(round(x1/0.001),round(y1/0.001))
port_b = kdb.Point(round(x2/0.001),round(y2/0.001))


vertex_ports: Dict[int, List[kdb.Point]] = { m1: [port_a, port_b] }
polygon_ports: Dict[int, List[kdb.Polygon]] = {}
rexer = klp.RNetExtractor(dbu=0.001)
try:
    network = rexer.extract(tech1, geo, vertex_ports, polygon_ports)
    print(f"PEX min_b=0 PASS: {network.to_s(with_coords=True)}\n")
except Exception as e:
    print(f"PEX min_b=0 ERROR: {e}\n")

try:
    network = rexer.extract(tech2, geo, vertex_ports, polygon_ports)
    print(f"PEX min_b=0.3 PASS: {network.to_s(with_coords=True)}\n")
except Exception as e:
    print(f"PEX min_b=0.3 ERROR: {e}\n")

try:
    m1_delaunay = region.delaunay(max_area=0, min_b=0)
    print(f"REGION min_b=0 PASS\n")
except Exception as e:
    print(f"REGION min_b=0 ERROR: {e}\n")

try:
    m1_delaunay = region.delaunay(max_area=0, min_b=0.3)
    print(f"REGION min_b=0.3 PASS\n")
except Exception as e:
    print(f"REGION min_b=0.3 ERROR: {e}\n")

ERROR: src/db/db/dbPLC.cc,543,false
PEX min_b=0 ERROR: Internal error: src/db/db/dbPLC.cc:543 false was not true in RNetExtractor.extract

ERROR: src/db/db/dbPLC.cc,543,false
PEX min_b=0.3 ERROR: Internal error: src/db/db/dbPLC.cc:543 false was not true in RNetExtractor.extract

REGION min_b=0 PASS

ERROR: src/db/db/dbPLC.cc,543,false
REGION min_b=0.3 ERROR: Internal error: src/db/db/dbPLC.cc:543 false was not true in Region.delaunay

 [const]    string  cell_name       Gets the name of the target cell currently addressed
 [const]    string  filename        Gets filename associated with the layout behind the cellview

pya.LayoutView().current().active_cellview().cell_name -> "test"
expected

pya.LayoutView().current().active_cellview().filename -> <built-in method filename of CellView object at 0x7f2ff9f280d0>
not what I expected !

both are '[const] string' should both return a string ?

However
pya.CellView().active().filename() -> test.GDS
does what I was expecting from
pya.LayoutView().current().active_cellview().filename

feature, bugs or missing something ?

My current case would encounter OASIS >500G, and for Klayout, when I do layout.read(), the memory basically uses >10x the oasis file size.
Is there a way to do streaming or another technique to deal with such huge memory usage scenario?

thx

I thought I can find something inside 'current_view()'

pya.Application.instance().main_window().current_view()

it seems I cannot find anything useful at this level

I tried to examine the content of

pya.Application.instance().main_window().current_view().begin_layers()

(with this simple script, that print some property of the layer, like : valid,.visible ...)

print("\n\nbegin_layers")
ap=pya.Application.instance().main_window().current_view().begin_layers()
while not ap.at_end() :
cur=ap.current()
print(cur)
print(cur.name,cur.valid,cur.visible)
ap.next()

Still nothing is telling what is the current active layer in the gui (may is there but I do not know how to access)
I also trying a "promising" LayerInfo(), pya.LayerInfo(), apparently intuition does not help.
I am on the wrong track...

I am currently working on a Python Macro that can receive probes for Nets or Cells from a Schematic Editor by the name specified in the netlist.

I am resolving the name using the .lvsdb and would theoretically only need to set the selection to the corresponding NetlistObjectsPath.

The documentation tells me that both selected_paths and current_path are setters (moving either one would work for my purpose).

Is there any workaround that would allow me to set the selected path in the Netlist Database Browser like a mouse click would without altering the C++ code?

Thank you very much in advance!

I am currently trying to fracture and decompose non-orthogonal shapes (such as circles or polygons with slanted edges) into purely orthogonal rectangles.

I have already tried using the decompose_trapezoids() and decompose_convex() methods via the Python API. However, they do not quite achieve what I am looking for.

What I actually want to achieve is a "staircase" approximation. As shown in the attached image, I am looking for a result where the shape is filled with a maximum inner rectangle (main field), and the curved edges are approximated by smaller, stepped rectangles (sub-fields).

(Please see the attached image for my desired output)

My questions are:
Is there any built-in method or parameter in KLayout that can enforce decomposition into pure rectangles?
If not natively supported, what would be the recommended approach or workaround using Python scripts?

Any guidance or code snippets would be greatly appreciated. Thank you in advance!

I am asking some help, because there is something that I can do using the GUI of klayout but I want to do it using a python script.
Using the GUI in edit mode, I read a GDS, I go to Edit/Layer/Edit Layer Specification and I update the layer number and datatype of some layer before writing down a new GDS.

However I did not success to do it using a script in batch mode.
The first thing I tried was to use a 'layer_map' from 'LoadLayoutOptions' but I do not retrieve the new layer in the written GDS.
Then I thought I need to copy the layer content in a newly created layer and then remove the old layer. It could works but the thing is I would like to map many datatype layers into the same datatype (for example layer 4.0, 4.1 and 4.2 became 16.0). In that case, does that mean I should perform a boolean operation to get that unique layer ?

Should I dig in the 'layer_map' solution ? Should I switch to OR operation solution ? Or is there another wy to do it ?
Thank you for your help

Note : Here is a trial with layer map

import pya as kl

ly = kl.Layout()
option = kl.LoadLayoutOptions()
option.layer_map.map("*/* : *+12/0", 0)
ly.read("my_file.gds", option)
## Display layer and datatype
for layer_idx in ly.layer_indexes():
  info = ly.get_info(layer_idx)
  print("Layer "+info.name+" : ",info.layer, info.datatype)

ly.write("my_new_file.gds.gz")

The KLayout documentation here mentions that every time a LayoutView is created, a copy of each plugin is created from its PluginFactory, and is activated when the button is pressed on the toolbar. But when created with a LayoutViewWidget, when there is no toolbar, how do you activate the plugin in that particular LayoutView?

My example is the following:

import pya as kl

class PluginTestFactory(kl.PluginFactory):
    def __init__(self):
        self.register(29318, "plugin_name", "test_plugin")
    def create_plugin(self, manager, dispatcher, view):
        return PluginTest(view)
class PluginTest(kl.Plugin):
    def __init__(self,view):
        print("Starting plugin")
        self.outside_view = (view != kl.Application.instance().main_window().current_view())
    def mouse_click_event(self, p, buttons, prio):
        if prio and self.outside_view:
            print("Mouse clicked inside secondary view!")
        elif prio:
            big_menu = kl.QDialog(kl.Application.instance().main_window())
            big_menu.layout = kl.QGridLayout()
            containing_layout = kl.QWidget()
            self.layoutwidg = kl.LayoutViewWidget(containing_layout)
            cv = self.layoutwidg.view().create_layout(True)
            viewing_layout = self.layoutwidg.view().cellview(cv).layout()
            big_menu.layout.addWidget(self.layoutwidg,0,0,1,1)
            big_menu.show()
if __name__ == "__main__":
    PluginTestFactory()

I can't figure out how to get the "Mouse clicked inside secondary view!" string to ever print. How do I activate the plugin in the new LayoutView, so that it can be printed?

The following function returns true if a point lies inside a polygon (specified by layer and a cell).
However I don't want to use this method because I don't want to iterate over all the shapes.
Is there a simpler way of finding if a point is inside or outside (touching or not touching) a specified layer.

iter = pya.RecursiveShapeIterator.new(layout, cell, layer_index)
specified_region = iter.shape().polygon
is_point_inside = specified_region.inside(pya.Point(x, y))

Thanks for the help!

I am using Python to create a complicated layout.
In it, I created a cell which contains a whole Die. This cell is inserted into the top cell which contains the entire wafer.

I can manually select the cell, go edit->selection->make array and duplicate it to cover the wafer. Can this be done in the Python script?

For simplifying, let's assume there's a cell named "Cell_Die" which has a single 2000x3000um box in it. I want it to be duplicated with dx=3000 and dy=4000 over the entire wafer (a cell named "Cell_Wafer"), and also be able to move it slightly (for example in the above scenario, I want the wafer end to be at x=1500 of the die that touches it).

Thanks for the help!
Shoval.

This question is more of a geometric question but I'm sure you will have a very short and simple code that can help a lot:
Say I want to align an image to a layout. Both the image and the layout have a set of 3 matching respective landmarks.
So the image landmarks set is: (Im1x,Im1y) (Im2x,Im2y) (Im3x,Im3y) and the layout landmark set is (La1x,La1y) (La2x,La2y) (La3x,La3y)

Can you suggest a code that will transpose the image to the layout using above landmarks coordinates?

Thanks for your time and effort! Itamar

I would like to switch layouts but without losing the handle
I have the following example code:

mw = pya.Application.instance().main_window()
mw.create_view()
ly1 =  pya.Layout()
ly1.read( "design1.oas")
ly2 =  pya.Layout()
ly2.read( "design2.oas")
mw.current_view().show_layout(ly1, False)
mw.current_view().show_layout(ly2, False)
mw.current_view().show_layout(ly1, False)

on the last line I am getting the error: Object has been destroyed already for argument #1 ('layout') in LayoutViewBase.show_layout

I understand from it that layoutview.show layout is then destroying the previous design
is there a way to switch layouts views without destroying them?

I know you are probably going to hate me for this

But do you have a somewhat comprehensive list of what is thread-safe in KLayout?

Out of interest (and because in some cases it would be somewhat useful) I made a kfactory version which in the new python 3.14 works with the freethreading (i.e. no GIL). I know that you mentioned before that KLayout should be reasonably thread-safe if you are not modifying a cell or any of it's children while working on it.

But to me it even fails on c.each_inst() when another cell is currently being built. each_inst() even fails for an empty cell. This fails with a topological sort error.

Do you have any advice how I could fix this or what might cause this?

If you would like to test it, the branch is here https://github.com/gdsfactory/kfactory/tree/add-3.14-threading

Test case is the following:

import time
from concurrent.futures import ThreadPoolExecutor
from threading import get_ident

import kfactory as kf

kf.config.logfilter.level = "DEBUG"


def busy_wait(duration: float) -> None:
    """Actively burn CPU time for `duration` seconds."""
    start = time.perf_counter()
    while (time.perf_counter() - start) < duration:
        pass  # no sleep, no yield — pure busy loop


@kf.cell
def straight(length: int) -> kf.KCell:
    c = kf.KCell()
    layer = c.kcl.layer(1, 0)
    # c.shapes(layer).insert(kf.kdb.Box(length, 500))
    # busy_wait(1)
    # print(f"{length=}")
    return c

def test() -> kf.kdb.Cell:
    c = ly.create_cell(name=f"{get_ident()}")
    c.name = str(c.cell_index())
    return c


def main() -> None:
    with ThreadPoolExecutor(max_workers=32) as executor:
        start = time.perf_counter()

        futures = [executor.submit(straight, i * 1000 + 100) for i in range(2000)]

        for i, f in enumerate(futures):
            try:
                f.result()
            except Exception as e:
                raise RuntimeError(f"Failed to build for {i=!r}") from e
        end = time.perf_counter()

    print(f"Took {end - start:.2f} seconds")


if __name__ == "__main__":
    main()

• The Region became empty (see the debug file).
• The area of the Region is non-zero even though it is empty (it remained to the value before the region vanished).

Can you explain this behavior? Where is it documented? Is the Region holding data itself or is it a view in the memory of the database?
Olivier

import pya

mw = pya.MainWindow.instance()      # MainWindow
lv = pya.LayoutView.current()       # LayoutView
cv = lv.active_cellview()           # CellView
layout = cv.layout()                # Layout

cell = layout.cell("TOP")           # Cells
hole = layout.cell("Hole")

iter = cell.begin_shapes_rec(layout.find_layer(2,0))
iter.maxdepth = 0
r = pya.Region(iter)                # Create Region 'r'

print("(1) Area: ", r.area())

for inst in cell.each_inst():       # Delete a cell instance
  if inst.cell.name == "Hole":
    inst.delete()   

print("(2) Area: ", r.area())       # Check Region 'r'
r.write("debug.gds")

# Setup the display
lv.reload_layout(cv.index())            # Reload original file
mw.load_layout("debug.gds", mode=1)     # Display the debug file

• A new layout is created and a new cell named "XOR" is created in this layout. --> OK
• Region r is created, with the correct non-zero area (when ra and rb differ). --> OK
• A layer is created with the expected layer number... but that layer remains empty!

Could you explain why the layer is not populated and what should be done to obtain the result?
Oliver

"""Compare designs."""
A_cell, B_cell = None, None

mv = pya.MainWindow.instance()

for lv_idx in range(mv.views()):
  lv = mv.view(lv_idx)
  print(f"Open LayoutView {lv_idx}: " + lv.title)

  for cv_idx in range(lv.cellviews()):
    cv = lv.cellview(cv_idx)
    print(f"Search cell in CellView {cv_idx}: " + cv.name)

    if cv.name == "Test_A.gds":
      A_ly = cv.layout()
      A_cell = A_ly.cell("TOP")
      print("-> A_cell found.")

    if cv.name == "Test_B.gds":
      B_ly = cv.layout()
      B_cell = B_ly.cell("TOP")
      print("-> B_cell found.")


if (A_cell is None) or (B_cell is None):
  raise RuntimeError("Error: Target cells were not found.")
else:
  print("--> Target cells were found.")

LAYER_PAIRS =  [[ (19,0), (19,0) ]]

cv = mv.create_layout(mode=1)
ly = cv.layout()
cell = ly.create_cell("XOR")

for (a,b) in LAYER_PAIRS:
  a_idx = A_ly.find_layer(a)
  b_idx = B_ly.find_layer(b)

  ra = pya.Region(A_cell.begin_shapes_rec(a_idx))
  print("Region a: ", ra.area())
  rb = pya.Region(B_cell.begin_shapes_rec(b_idx))
  print("Region b: ", rb.area())
  r = ra ^ rb
  print("Region a^b: ", r.area())

  idx = ly.layer(a)
  cell.shapes(idx).insert(r)

I have a technology file for which I've set a custom base path (outside of ~/.klayout). It follows the standard KLayout technology structure with a pymacros/ subdirectory containing both a .lym (set to auto-run) that imports .py files.

KLayout does not seem to have trouble finding this pymacros/ directory since they show up in the per-technology Python scripts in the Macro Editor. However, if I have e.g. Disk.py and try to import Disk from the .lym file, I get an error "No module named 'Disk' (Class ModuleNotFoundError)".

I have to add:

import sys
sys.path.append("/path/to/my/tech/pymacros")

Before this will work.

The macro editor documentation suggests that "Technology folders: each technology folder can carry a "macros" or "pymacros" subfolder where technology-specific macros are kept" which seems to imply that the technology folder should automatically be added to the import path.

Is this the intended behavior? Would you consider automatically adding the technology path pymacros/ folder so that it is importable?

I'm trying to install the most updated version of Klayout from source on an offline version of Ubuntu 18.04, and it has only Qt 5.9.5. It therefore causes trouble when trying to install src/gsiqt/qt5/QtCore/gsiDeclQAbstractItemModel.cc (among other possible issue spots) because in Qt5.11 the CheckIndex function was added to QAbstractItemModel, and it appears Klayout added handling for that in commit 31aa45d.

My question is: when pre-building the .deb files for Ubuntu 18.04, how is this bindings issue handled? I would like to use Qt bindings, and I'll update my Qt installation if I have to, but I'm just wondering what the current handling for this mismatch is. Thanks!

-Noah

I noticed that KLayout python package got updated over the weekend, so I tried to include it in our project, but it caused CI pipeline to fail. The problem boils down to trying to run this code in python:

import klayout.lay
x = klayout.lay.Plugin()

With klayout==0.30.3 this executes just fine. With klayout==0.30.4 I get error:

AttributeError: module 'klayout.lay' has no attribute 'Plugin'

I suspect this module got renamed or moved somewhere due to these changes?

What would be the recommended way of using features under the Plugin and PluginFactory classes?

I was attempting on implementing a TypeCallback clickable button + callback_impl(self, name) function to trigger changes on the parameters of a PCell with a click (for example, setting defaults/specific parameters).

When going for it, self.name = xx wouldn't work, and self.name.value=(xx) only seems works within the scope of the function callback_impl (checking the value change with print(self.name.value)).

I thought that maybe this was the intended implementation, for callback_impl to only affect the UI with enabled, readonly, visible or icon.
But then I found that using self.name.value=(xx) AND changing the state of any of the former properties, the changed value would pass through and materialize in the PCell itself.

I suppose it's a bug. An example:

def callback_impl(self,name):

if name == "callbackButton":

self.propertyName.value=(4.0)

self.propertyName.readonly = not(self.propertyName.readonly)

Thank you,
Gerard

P.D. I'll describe what I'm actually trying to achieve with all this, just for context purposes:

I'm trying to use libraries (static or other PCells) within a PCell so that a layout can build itself by combining these hierarchical PCells.
Segregating PCells is useful in case we want one of the building blocks for manual placement, and would also allow to implement external libraries compatible with the purpose of the PCell (maybe combining it with a metadata identifier), and still adjust the parent PCell to accommodate and perform any dependant operation for the child components.
Ideally, the PCell library would use itself to build other entries of the same library. That would be doable by calling the definition of the required PCell in another script, or external cell within the definition assuming that it's already present somewhere when executing the PCell.
This would allow to:

• Simplify PCell definitions: Split PCells into managable pieces which are easier to maintain
• Versatility: Use one of the building blocks on its own for manual designs and without redundancy
• Custom programatic grouping: Call PCells within a PCell for ease of use/convenience
• Build modifying other cells: Use PCells to convert them as static and apply further transformations
• Build on top of other cells: Perform dependant operations on the child (like booleans/fill) and add extra polygons to make a next hierarchical step PCell parent while maintaining the original instance reference
• Build with interacting cells: Smart interaction between PCells with the usage of defined relationship properties or metadata inserted into the cell

Hence I need to add any external source to a PCell and the only way I could think of is by specifying the name of the cell/pcell and look for it in embedded libraries or existing cells within the layout. The most convenient way to add one would be with a dropdown menu, but there's no TypeLayer equivalent for cells and/or library entries, and I don't know how to dynamically load the choices property of the TypeList. I assume that this is incompatible within the PCell definition as it is a segregated unit of sorts.
Then I thought, what if I execute a function that opens a custom popup with a list populated with all the existing cells and library entries of the session, for then to return the string of the selected entry? And here is where I had trouble on changing the state of a TypeString on a callback event.

I don't know if it is possible to interactively trace a net (as usual) and to tie a post trigger (or something similar) to the 'Export To Net' button to post-process the XML output file? My main goal would be to save 'box' entities with their real layer name instead of gds number/datatype pair. Basically the same as 'polygon' entities. The coupled post-processing script would need access to the .lyp file, i think, to make the mapping. What could be a good approach to do this?

Thanks.

writer = gdstk.GdsWriter()
cell1 = some_function_that_creates_a_huge_cell()
writer.write(cell1)
del cell1
cell2 = some_function_that_creates_a_huge_cell()
writer.write(cell2)
del cell2
writer.close()

How to do it in klayout ?

Is there a function in pya module can realise this.