dry_run = true
eps = 1.dbu

layers.each do |spec, name|
  l = input(spec)
  l.raw.with_area(0).output("Zero-area polygon on #{name} (#{spec})")
  l.raw.edges.with_length(0).output("Zero-length edge on #{name} (#{spec})")
  l.raw.width(eps).output("Zero/near-zero width spike on #{name} (#{spec})")
  l.raw.notch(eps).output("Zero/near-zero gap notch on #{name} (#{spec})")
end

Unfortunately it does not detect this two cases:
1. Path spike Spike in path at location (2221.925,2907.7) in cell SoC7610 on layer 50 datatype 0.

Path of width 1.02  on metal4 50/0 
2271.28000 2901.51500
2271.28000 2907.70000
2221.92500 2907.70000
2222.02500 2907.70000

2. Metal polygon

99.78500    12.30000
99.78500    43.46000
84.50500    43.46000
103.03500   43.46000
103.03500   43.26000
100.08000   43.26000
100.08000   12.30000

with the problematic point 84.50500 43.46000

image

We suggest to save the layout with the option "Eliminate zero-length paths (conver to BOUNDARY)" but still it does not filter out all cases.
Any suggestion on how we could proceed ?

I tried HW-klayout-0.29.11-macOS-Sonoma-1-qt5MP-RsysPhb311.dmg but this doesn't open - it only crashes when run (crash report window appears)

Next I tried ST-klayout-0.29.11-macOS-Ventura-1-qt5MP-RsysPsys.dmg but nothing happens when I try to open this version of Klayout.

There are a vast number of *dmg files to pick from. I have no idea what would run on my laptop.

How to reproduce the problem

1. enable all (all filters are mark as active, everything is selectable)
2. disable instance (all filters are mark as active but instance, work as expected instances are not selectable )
3. disable all (all filters are mark as active but instance ! nothing is selectable )
4. enable all (all filters are mark as active but instance ! everything is selectable )
5. enable instance (all filters are mark as active, instance are not selectable)

After I few back and forward between 'enable/disable all' and filter selection, the meaning of the check mark
on the filter is completely out of sync with what happen in the real layout.

I guess the intent was to have 'enable/disable all' to turn ON/OFF all the filters, then use the filter check mark to turn ON/OFF each
individual object selection.

I am researching if this could help me into what I am trying to achieve.
My first target is to understand if this can enable to completely deconstruct/reconstruct (import/export) a layout into a library.
Maybe you have already an answer to that, otherwise:

• is it possible in a library layout file to have cells coming from itself
• When a layout containing library references is saved, KLayout stores some meta information: does it also save the layout, or is it possible to not save the layout?
• if both points are valid, when we import a cell from a library with a reference to another cell it is possible to have the full hierarchy ?
• finally what is the format of the metadata, is there any python APIs to code it?

Thanks!

 [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 ?

I am trying to access library cells through python scripting.
I can see the list of all libraries- when I use print(pya.Library.library_names())
But when I try to access that library using pya.Library.library_by_name() it gives an output "None"
The technology file was loaded using Tools--> Manage Technologies, and is also copied in the "tech" and "salt" folders.
How can I access this library through scriting. Please help!

Niharika

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

Implementing via check
apparently klayout does not provide a check for via, in the sense the width is fix for instance 0.26um.

The obvious solution will be to check for size > 0.26 and < 0.26.

via1.drc(width > 0.26).output("VIA1.W.1", "VIA1 width > 0.26") (expected true if via width > 0.26um) failed !
via1.drc(width < 0.26).output("VIA1.W.2", "VIA1 width < 0.26") (expected true if via width < 0.26um) works !
or
via1.drc(width != 0.26).output("VIA1.W.3", "VIA1 width != 0.26") (expected true if via width != 0.26um) failed !

projection, no help
Does width work only for < ?

if yes then there is some problem with these examples

errors = in.drc(width < 0.2.um)
errors = in.drc(width <= 0.2.um)
errors = in.drc(width > 0.2.um)
errors = in.drc(width >= 0.2.um)
errors = in.drc(width == 0.2.um)
errors = in.drc(width != 0.2.um)
errors = in.drc(0.1.um <= width < 0.2.um)

What controls that scaling, for the print process?
Other features look same-same vs display.

I’m working in KLayout (version 0.30.4) and running into a snapping issue that I can’t seem to resolve.

I need to draw rectangular boxes around some text. When I use the Ruler tool, it correctly detects edges/corner points of the text — the cursor changes and snaps precisely to those points.

However, when I switch to the Box tool, the cursor does not snap to those same points, and I cannot accurately align the box to the text corners.

On another machine (work PC), KLayout does snap correctly when drawing boxes, so I believe this functionality exists but may depend on some configuration, mode, or template setting.

Can anyone please tell me how to fix this. Any guidance would be greatly appreciated.

Thanks!

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 have recently tried to detect gaps which can appear in our gds files (generated by gdsfactory) when we have an instance with a non-manhattan rotation (neither half-mahattan) to which we connect another instance.
The kind of artifacts we would get are gaps which are around 0.2-0.8nm long (DBU=1nm) as it can be seen in the following image:

The unzoomed image is:

For finding them, I tried the following script

LAYER = input(400, 0)
threshold = 0.005
merged = LAYER.merged
closed = merged.sized(threshold).sized(-threshold)
issues = closed.not(LAYER)
# Then output either to report or layer, whatever

However the issues layer I have at the end is not covering the gaps at all if they're too small, or weirdly if large enough (which works sufficiently for my use case I'd say)
Also a side effect of using this sized method is that the issues layer tend to appear here and there on the edges of my non-manhattan oriented polygons

From my understanding all of this happens due to the points snapping on the grid as precisely as possible and thus producing those artifacts.
Is there any other way I could try to detect them? I can provide more examples if needed.

Thanks

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!

Hope you are doing well,

In the context of gf180, I've been experimenting with DRC, how to make it faster and improve quality of life from a GUI user point of view.
My initial issue was the speed of the DRC deck. For a somewhat simple full chip design, deep DRC, I was getting run times of more than 20 minutes on my beefy computer when starting the DRC from the GUI.
I knew that there should be some way to improve this, because CPU utilization was generally low, albeit with some large spikes. That gave me the feeling that the process was memory-bound instead of cpu bound.
The gf180 pdk (same with IHP) also provides a python utility, where each file was run in its own klayout process. This considerably improves speed (~5x), but suffers from a few issues:
1) Each run generates its own reports, checking for DRC clean is a nightmare
2) General layers have to be recomputed each time. While this does not always result in longer run time depending on number of cores, it is a certain limitation. Moreover, the general layers are duplicated in ram for each process, causing a larger memory usage.

I've experimented a bit and implemented my own DRC approach to try and solve both issues. It is implemented fully in ruby using forks, and has great performance (similar performance as the python script with untapped potential and less RAM usage).

Here are the currently issues preventing it from being merged to upstream PDK

GUI Cancel

Due to something in QT/graphics driver panicking when joining threads in GUI, I have to run the forking script in a klayout batch mode process. This means that (1) the project has to be saved to disk before running DRC, but more importantly that (2) there are currently no way of canceling a DRC run from the GUI.
(2) is because it seems there are no cancel flags exposed from the C++ to ruby API. From my understanding, the cancel action causes the C++ side DRC calculation function to throw an exception, which is caught from ruby. In my case, I do not think I can use this approach in a clean manner.

Report merging and report files

My first issue with drc reports is that there is currently no way of obtaining one without creating a file. That means that in case of parallel DRC runs, I have to create one temporary file per run, which is not so clean. I implemented a basic functionality allowing to get reports as a string rather than a file here, but I don't think it is very good. I then reverted to using files.

My second and bigger issue is that there is no way of merging report files together, so that it is presented cleanly in the GUI report view. In the present case, we only need a simple approach, as we are guaranteed that the top cell of all report files is the same. I've implemented this outside klayout here. Beware, that specific part is mainly AI (goal was proof of concept).

Conclusion

Do you think that this approach to DRC is sane?
How would you see the cancel functionality implemented? Is there some way I did not think of, or new functionality is need on the klayout side?
Same thing with the report file merging. If you guide me a bit (where to implement this function), I could try to make an MR.

Thanks!

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")

I'm using KLayout (version 0.30.1 on Linux) for the DRC.
In photonics, some layers can have complex structures (many curves), and running a DRC on these structures can take many hours (>24 hours), and it is not uncommon that KLayout crashes in the end (because out of memory (>96 GB)).
Therefor, we want to exclude certain areas in a layer from the DRC.
(Even for simple structures, this is necessary because for finding overlaps of polygons within a single layer, it is sometimes allowed to have overlaps at specific locations. In photonics, 2 waveguides in the same layer may sometimes cross each other. So, we want to exclude these areas also from the DRC.)

So, I create a new layer, and place some polygons (the exclusion areas) in it. And I do the DRC check on

layer.not(exclusion_layer)

But this doesn't work, because after the boolean NOT operation, the layer is in 'clean' state, and this causes problems finding the overlaps.

Let me explain this with an example.

The left red cross in the layout are 2 straights (a horizontal and a vertical) in the same layer (layer 1).
I find the overlap with:

layer1 = input(1)
layer1.merged(2).output("Overlap layer1")

This gives the expected overlap.

The right purple 'double' cross in the layout are 2 horizontal straights, and these straights overlap with a vertical straight. These 3 straights are in layer 2. When I run the same check again (without using an exclusion layer), I get 2 overlaps (as expected) Call this the 'top-overlap' and the 'bottom-overlap'.

layer2 = input(2)
layer2.merged(2).output("Overlap layer2")

Now add the exclusion layer (layer 24, green).

exclusion_layer = input(24)

When I run the last overlap test again, I want to find the 'top-overlap', but not the 'bottom-overlap', because the exclusion layer has created a 'hole' at that spot.

layerEx = layer2.not(exclusion_layer)
layerEx.merged(2).output("Overlap layer2 with exclusion layer")

But this doesn't work. The 'bottom-overlap' is gone (good!), but the 'top-overlap' is also gone (bad!).
I discovered that the boolean NOT operation creates a layer in the CLEAN state (the merging has already been
done by the NOT operation). (Calling merged(2) on an already merged layer is pointless.)

layer2.not(exclusion_layer).is_merged? returns true.

I tried the following, but that didn't work:

layerExRawRaw = input(2).raw.not(input(24).raw)
layerExRawRaw.merged(2).output("Overlap layer2 (RawRaw) with exclusion layer")

How do I use an exclusion layer that only creates 'holes' in another layer, while leaving the rest of that layer unchanged (the layer remains in raw-state)?

(We also need this exclusion layer for other checks than the overlap check.)

Thanks, Remco

Remark: I also have the GDS file and the DRC file, but this forum blocks uploading these files. The "Attach file" only allows uploading images, which is the same as the "Attach image" button. Looks like a bug?

Not sure how to get it back down to a reasonable size. Any suggestions?

Thanks Mike

I noticed that on latest versions (i tried on 0.30.5), markers frames always show when adding a marker to LayoutView (0.28.5 does not do that).
Is there a way to turn off marker frames?
I also tried to set the frame color to be the same as the background color but it sets both the marker and the frame.

Thanks!

def addTextMarker(self,layoutView, x,y,string,color):
  m = pya.Marker(layoutView)
  bgColor = pya.QColor(layoutView.get_config("background-color"))
  m.color = color.red*65536 + color.green*256 + color.blue
  m.frame_color = bgColor.red*65536 + bgColor.green*256 + bgColor.blue      
  m.set_text(pya.DText(string,pya.DTrans(pya.DPoint(x,y))))   
  m.line_width = 10