• ## Feeds

Vanilla 1.1.4 is a product of Lussumo. More Information: Documentation, Community Support.

• CommentAuthorUiara
• CommentTimeFeb 26th 2018

Hi Matthias,

I wonder if it is possible to perform a width check for widths between two values.

I mean: min <= width < max

The same way we do by using the function layer.width(value) for a min value, also returning an edge pair error shape.

Thank you!
• CommentAuthorMatthias
• CommentTimeFeb 26th 2018 edited

Hi,

edge pairs are only defined for "less than" type of checks - complex checks render figures that cannot be represented by edge pairs. So there is not a single operation that delivers this.

You can however select edges with "width > min" and then do a width check with "max" on the same:

``````l = input(1, 0)

# will render edges where the input is less than 2um wide
less_than_2um = l.width(2.0.um).edges

# returns all other edges (i.e. where the width is >= 2um)
more_than_2um = l.edges - less_than_2um

# delivers the places where these edges are opposite and less than 4um apart
between_2_and_4um = more_than_2um.width(4.0.um)
``````

Note, that this solution may also render edge pairs from edges which don't belong to the same original polygon, so it's safe only under certain conditions.

A solution that is safe against this, but does not render edge pairs is the following. It uses edge booleans to produce edge flags based on multiple conditions:

``````# will render edges where the input is less than 2um wide
less_than_2um = l.width(2.0.um).edges

# will render edges where the input is less than 4um wide
less_than_4um = l.width(4.0.um).edges

# will render edges where the second condition is met but not the first one
between_2_and_4um = less_than_4um - less_than_2um
``````

Regards,

Matthias

• CommentAuthorUiara
• CommentTimeFeb 28th 2018

Thank you very much, Matthias!

I used the first risky option because I really need the edge pairs :)

Up to now it is working fine.

Best regards,
• CommentAuthorMatthias
• CommentTimeFeb 28th 2018 edited

I wouldn't call it risky ... it's just harder to control.

One situation where this fails is the following: imagine you have a check for width between 1 and 3 µm and two parallel lines of 1 µm width spaced 0.5 µm. Then you will get three edge pairs: two for the two lines and one for the outer edges being 2.5 µm apart. The third is the one that you might not want to have. You need to be aware of this possibility. Maybe your layout is made in a way this can't happen. Then you're safe.

Kind regards,

Matthias

EDITED: typo (... in a way ...)

• CommentAuthorUiara
• CommentTimeMar 1st 2018

Hi Matthias,

I will check this.
But it is better for me to have this false alarms, but guarantee that I will find the real problems.

Thank you very much again!

Best regards,
Uiara
• CommentAuthorfx99
• CommentTimeMar 6th 2018

Hi Everyone,

I used sizing operations to detect structures with a certain width range:

mins2=1.1
maxs2=1.8
met1w1= met1.sized(-mins2).sized(mins2)
#met1w1.output("width(met1) > #{mins2*2} ")
met1w2= met1w1.sized(-maxs2).sized(maxs2)
#met1w2.output("width(met1) > #{maxs2*2} ")

met1m = met1w1 - met1w2
met1m.output("#{mins2*2} <= width(met1) < #{maxs2*2}")

It works well on a small test circuit, but I am not sure about the general behavior.

Regards,

Harald
• CommentAuthorUiara
• CommentTime4 days ago

Thank you, Harald!